mirror of
https://github.com/gpujs/gpu.js.git
synced 2026-01-25 16:08:02 +00:00
0cce0a0a82
Add unit tests to browser all.html fix a typo in file and in desc Add a few missing items to index.d.ts Move debug console.log to match GPU counterpart Build files All unit tests pass or skip (when appropriate) for Chrome, Firefox, Safari, and Node This marks v1 rc1.
11976 lines
337 KiB
JavaScript
11976 lines
337 KiB
JavaScript
/**
|
|
* gpu.js
|
|
* http://gpu.rocks/
|
|
*
|
|
* GPU Accelerated JavaScript
|
|
*
|
|
* @version 2.0.0
|
|
* @date Sun Feb 10 2019 22:55:24 GMT-0500 (Eastern Standard Time)
|
|
*
|
|
* @license MIT
|
|
* The MIT License
|
|
*
|
|
* Copyright (c) 2019 gpu.js Team
|
|
*/(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
|
|
(function (global, factory) {
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
|
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
|
(factory((global.acorn = {})));
|
|
}(this, (function (exports) { 'use strict';
|
|
|
|
|
|
var reservedWords = {
|
|
3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",
|
|
5: "class enum extends super const export import",
|
|
6: "enum",
|
|
strict: "implements interface let package private protected public static yield",
|
|
strictBind: "eval arguments"
|
|
};
|
|
|
|
|
|
var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
|
|
|
|
var keywords = {
|
|
5: ecma5AndLessKeywords,
|
|
6: ecma5AndLessKeywords + " const class extends export import super"
|
|
};
|
|
|
|
var keywordRelationalOperator = /^in(stanceof)?$/;
|
|
|
|
|
|
|
|
var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08bd\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fef\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7b9\ua7f7-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab65\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
|
|
var nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d3-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf2-\u1cf4\u1cf7-\u1cf9\u1dc0-\u1df9\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
|
|
|
|
var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
|
|
var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
|
|
|
|
nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
|
|
|
|
|
|
var astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,14,29,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,477,28,11,0,9,21,190,52,76,44,33,24,27,35,30,0,12,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,54,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,86,26,230,43,117,63,32,0,257,0,11,39,8,0,22,0,12,39,3,3,20,0,35,56,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,270,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,689,63,129,68,12,0,67,12,65,1,31,6129,15,754,9486,286,82,395,2309,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,4149,196,60,67,1213,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,15,7472,3104,541];
|
|
|
|
var astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,574,3,9,9,525,10,176,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,4,9,83,11,7,0,161,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,280,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,19306,9,135,4,60,6,26,9,1016,45,17,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,2214,6,110,6,6,9,792487,239];
|
|
|
|
function isInAstralSet(code, set) {
|
|
var pos = 0x10000;
|
|
for (var i = 0; i < set.length; i += 2) {
|
|
pos += set[i];
|
|
if (pos > code) { return false }
|
|
pos += set[i + 1];
|
|
if (pos >= code) { return true }
|
|
}
|
|
}
|
|
|
|
|
|
function isIdentifierStart(code, astral) {
|
|
if (code < 65) { return code === 36 }
|
|
if (code < 91) { return true }
|
|
if (code < 97) { return code === 95 }
|
|
if (code < 123) { return true }
|
|
if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)) }
|
|
if (astral === false) { return false }
|
|
return isInAstralSet(code, astralIdentifierStartCodes)
|
|
}
|
|
|
|
|
|
function isIdentifierChar(code, astral) {
|
|
if (code < 48) { return code === 36 }
|
|
if (code < 58) { return true }
|
|
if (code < 65) { return false }
|
|
if (code < 91) { return true }
|
|
if (code < 97) { return code === 95 }
|
|
if (code < 123) { return true }
|
|
if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)) }
|
|
if (astral === false) { return false }
|
|
return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes)
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
var TokenType = function TokenType(label, conf) {
|
|
if ( conf === void 0 ) conf = {};
|
|
|
|
this.label = label;
|
|
this.keyword = conf.keyword;
|
|
this.beforeExpr = !!conf.beforeExpr;
|
|
this.startsExpr = !!conf.startsExpr;
|
|
this.isLoop = !!conf.isLoop;
|
|
this.isAssign = !!conf.isAssign;
|
|
this.prefix = !!conf.prefix;
|
|
this.postfix = !!conf.postfix;
|
|
this.binop = conf.binop || null;
|
|
this.updateContext = null;
|
|
};
|
|
|
|
function binop(name, prec) {
|
|
return new TokenType(name, {beforeExpr: true, binop: prec})
|
|
}
|
|
var beforeExpr = {beforeExpr: true};
|
|
var startsExpr = {startsExpr: true};
|
|
|
|
|
|
var keywords$1 = {};
|
|
|
|
function kw(name, options) {
|
|
if ( options === void 0 ) options = {};
|
|
|
|
options.keyword = name;
|
|
return keywords$1[name] = new TokenType(name, options)
|
|
}
|
|
|
|
var types = {
|
|
num: new TokenType("num", startsExpr),
|
|
regexp: new TokenType("regexp", startsExpr),
|
|
string: new TokenType("string", startsExpr),
|
|
name: new TokenType("name", startsExpr),
|
|
eof: new TokenType("eof"),
|
|
|
|
bracketL: new TokenType("[", {beforeExpr: true, startsExpr: true}),
|
|
bracketR: new TokenType("]"),
|
|
braceL: new TokenType("{", {beforeExpr: true, startsExpr: true}),
|
|
braceR: new TokenType("}"),
|
|
parenL: new TokenType("(", {beforeExpr: true, startsExpr: true}),
|
|
parenR: new TokenType(")"),
|
|
comma: new TokenType(",", beforeExpr),
|
|
semi: new TokenType(";", beforeExpr),
|
|
colon: new TokenType(":", beforeExpr),
|
|
dot: new TokenType("."),
|
|
question: new TokenType("?", beforeExpr),
|
|
arrow: new TokenType("=>", beforeExpr),
|
|
template: new TokenType("template"),
|
|
invalidTemplate: new TokenType("invalidTemplate"),
|
|
ellipsis: new TokenType("...", beforeExpr),
|
|
backQuote: new TokenType("`", startsExpr),
|
|
dollarBraceL: new TokenType("${", {beforeExpr: true, startsExpr: true}),
|
|
|
|
|
|
eq: new TokenType("=", {beforeExpr: true, isAssign: true}),
|
|
assign: new TokenType("_=", {beforeExpr: true, isAssign: true}),
|
|
incDec: new TokenType("++/--", {prefix: true, postfix: true, startsExpr: true}),
|
|
prefix: new TokenType("!/~", {beforeExpr: true, prefix: true, startsExpr: true}),
|
|
logicalOR: binop("||", 1),
|
|
logicalAND: binop("&&", 2),
|
|
bitwiseOR: binop("|", 3),
|
|
bitwiseXOR: binop("^", 4),
|
|
bitwiseAND: binop("&", 5),
|
|
equality: binop("==/!=/===/!==", 6),
|
|
relational: binop("</>/<=/>=", 7),
|
|
bitShift: binop("<</>>/>>>", 8),
|
|
plusMin: new TokenType("+/-", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),
|
|
modulo: binop("%", 10),
|
|
star: binop("*", 10),
|
|
slash: binop("/", 10),
|
|
starstar: new TokenType("**", {beforeExpr: true}),
|
|
|
|
_break: kw("break"),
|
|
_case: kw("case", beforeExpr),
|
|
_catch: kw("catch"),
|
|
_continue: kw("continue"),
|
|
_debugger: kw("debugger"),
|
|
_default: kw("default", beforeExpr),
|
|
_do: kw("do", {isLoop: true, beforeExpr: true}),
|
|
_else: kw("else", beforeExpr),
|
|
_finally: kw("finally"),
|
|
_for: kw("for", {isLoop: true}),
|
|
_function: kw("function", startsExpr),
|
|
_if: kw("if"),
|
|
_return: kw("return", beforeExpr),
|
|
_switch: kw("switch"),
|
|
_throw: kw("throw", beforeExpr),
|
|
_try: kw("try"),
|
|
_var: kw("var"),
|
|
_const: kw("const"),
|
|
_while: kw("while", {isLoop: true}),
|
|
_with: kw("with"),
|
|
_new: kw("new", {beforeExpr: true, startsExpr: true}),
|
|
_this: kw("this", startsExpr),
|
|
_super: kw("super", startsExpr),
|
|
_class: kw("class", startsExpr),
|
|
_extends: kw("extends", beforeExpr),
|
|
_export: kw("export"),
|
|
_import: kw("import"),
|
|
_null: kw("null", startsExpr),
|
|
_true: kw("true", startsExpr),
|
|
_false: kw("false", startsExpr),
|
|
_in: kw("in", {beforeExpr: true, binop: 7}),
|
|
_instanceof: kw("instanceof", {beforeExpr: true, binop: 7}),
|
|
_typeof: kw("typeof", {beforeExpr: true, prefix: true, startsExpr: true}),
|
|
_void: kw("void", {beforeExpr: true, prefix: true, startsExpr: true}),
|
|
_delete: kw("delete", {beforeExpr: true, prefix: true, startsExpr: true})
|
|
};
|
|
|
|
|
|
var lineBreak = /\r\n?|\n|\u2028|\u2029/;
|
|
var lineBreakG = new RegExp(lineBreak.source, "g");
|
|
|
|
function isNewLine(code, ecma2019String) {
|
|
return code === 10 || code === 13 || (!ecma2019String && (code === 0x2028 || code === 0x2029))
|
|
}
|
|
|
|
var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
|
|
|
|
var skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
|
|
|
|
var ref = Object.prototype;
|
|
var hasOwnProperty = ref.hasOwnProperty;
|
|
var toString = ref.toString;
|
|
|
|
|
|
function has(obj, propName) {
|
|
return hasOwnProperty.call(obj, propName)
|
|
}
|
|
|
|
var isArray = Array.isArray || (function (obj) { return (
|
|
toString.call(obj) === "[object Array]"
|
|
); });
|
|
|
|
|
|
var Position = function Position(line, col) {
|
|
this.line = line;
|
|
this.column = col;
|
|
};
|
|
|
|
Position.prototype.offset = function offset (n) {
|
|
return new Position(this.line, this.column + n)
|
|
};
|
|
|
|
var SourceLocation = function SourceLocation(p, start, end) {
|
|
this.start = start;
|
|
this.end = end;
|
|
if (p.sourceFile !== null) { this.source = p.sourceFile; }
|
|
};
|
|
|
|
|
|
function getLineInfo(input, offset) {
|
|
for (var line = 1, cur = 0;;) {
|
|
lineBreakG.lastIndex = cur;
|
|
var match = lineBreakG.exec(input);
|
|
if (match && match.index < offset) {
|
|
++line;
|
|
cur = match.index + match[0].length;
|
|
} else {
|
|
return new Position(line, offset - cur)
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
var defaultOptions = {
|
|
ecmaVersion: 7,
|
|
sourceType: "script",
|
|
onInsertedSemicolon: null,
|
|
onTrailingComma: null,
|
|
allowReserved: null,
|
|
allowReturnOutsideFunction: false,
|
|
allowImportExportEverywhere: false,
|
|
allowAwaitOutsideFunction: false,
|
|
allowHashBang: false,
|
|
locations: false,
|
|
onToken: null,
|
|
onComment: null,
|
|
ranges: false,
|
|
program: null,
|
|
sourceFile: null,
|
|
directSourceFile: null,
|
|
preserveParens: false,
|
|
plugins: {}
|
|
};
|
|
|
|
|
|
function getOptions(opts) {
|
|
var options = {};
|
|
|
|
for (var opt in defaultOptions)
|
|
{ options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]; }
|
|
|
|
if (options.ecmaVersion >= 2015)
|
|
{ options.ecmaVersion -= 2009; }
|
|
|
|
if (options.allowReserved == null)
|
|
{ options.allowReserved = options.ecmaVersion < 5; }
|
|
|
|
if (isArray(options.onToken)) {
|
|
var tokens = options.onToken;
|
|
options.onToken = function (token) { return tokens.push(token); };
|
|
}
|
|
if (isArray(options.onComment))
|
|
{ options.onComment = pushComment(options, options.onComment); }
|
|
|
|
return options
|
|
}
|
|
|
|
function pushComment(options, array) {
|
|
return function(block, text, start, end, startLoc, endLoc) {
|
|
var comment = {
|
|
type: block ? "Block" : "Line",
|
|
value: text,
|
|
start: start,
|
|
end: end
|
|
};
|
|
if (options.locations)
|
|
{ comment.loc = new SourceLocation(this, startLoc, endLoc); }
|
|
if (options.ranges)
|
|
{ comment.range = [start, end]; }
|
|
array.push(comment);
|
|
}
|
|
}
|
|
|
|
var plugins = {};
|
|
|
|
function keywordRegexp(words) {
|
|
return new RegExp("^(?:" + words.replace(/ /g, "|") + ")$")
|
|
}
|
|
|
|
var Parser = function Parser(options, input, startPos) {
|
|
this.options = options = getOptions(options);
|
|
this.sourceFile = options.sourceFile;
|
|
this.keywords = keywordRegexp(keywords[options.ecmaVersion >= 6 ? 6 : 5]);
|
|
var reserved = "";
|
|
if (!options.allowReserved) {
|
|
for (var v = options.ecmaVersion;; v--)
|
|
{ if (reserved = reservedWords[v]) { break } }
|
|
if (options.sourceType === "module") { reserved += " await"; }
|
|
}
|
|
this.reservedWords = keywordRegexp(reserved);
|
|
var reservedStrict = (reserved ? reserved + " " : "") + reservedWords.strict;
|
|
this.reservedWordsStrict = keywordRegexp(reservedStrict);
|
|
this.reservedWordsStrictBind = keywordRegexp(reservedStrict + " " + reservedWords.strictBind);
|
|
this.input = String(input);
|
|
|
|
this.containsEsc = false;
|
|
|
|
this.loadPlugins(options.plugins);
|
|
|
|
|
|
if (startPos) {
|
|
this.pos = startPos;
|
|
this.lineStart = this.input.lastIndexOf("\n", startPos - 1) + 1;
|
|
this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length;
|
|
} else {
|
|
this.pos = this.lineStart = 0;
|
|
this.curLine = 1;
|
|
}
|
|
|
|
this.type = types.eof;
|
|
this.value = null;
|
|
this.start = this.end = this.pos;
|
|
this.startLoc = this.endLoc = this.curPosition();
|
|
|
|
this.lastTokEndLoc = this.lastTokStartLoc = null;
|
|
this.lastTokStart = this.lastTokEnd = this.pos;
|
|
|
|
this.context = this.initialContext();
|
|
this.exprAllowed = true;
|
|
|
|
this.inModule = options.sourceType === "module";
|
|
this.strict = this.inModule || this.strictDirective(this.pos);
|
|
|
|
this.potentialArrowAt = -1;
|
|
|
|
this.inFunction = this.inGenerator = this.inAsync = false;
|
|
this.yieldPos = this.awaitPos = 0;
|
|
this.labels = [];
|
|
|
|
if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === "#!")
|
|
{ this.skipLineComment(2); }
|
|
|
|
this.scopeStack = [];
|
|
this.enterFunctionScope();
|
|
|
|
this.regexpState = null;
|
|
};
|
|
|
|
Parser.prototype.isKeyword = function isKeyword (word) { return this.keywords.test(word) };
|
|
Parser.prototype.isReservedWord = function isReservedWord (word) { return this.reservedWords.test(word) };
|
|
|
|
Parser.prototype.extend = function extend (name, f) {
|
|
this[name] = f(this[name]);
|
|
};
|
|
|
|
Parser.prototype.loadPlugins = function loadPlugins (pluginConfigs) {
|
|
var this$1 = this;
|
|
|
|
for (var name in pluginConfigs) {
|
|
var plugin = plugins[name];
|
|
if (!plugin) { throw new Error("Plugin '" + name + "' not found") }
|
|
plugin(this$1, pluginConfigs[name]);
|
|
}
|
|
};
|
|
|
|
Parser.prototype.parse = function parse () {
|
|
var node = this.options.program || this.startNode();
|
|
this.nextToken();
|
|
return this.parseTopLevel(node)
|
|
};
|
|
|
|
var pp = Parser.prototype;
|
|
|
|
|
|
var literal = /^(?:'((?:\\.|[^'])*?)'|"((?:\\.|[^"])*?)"|;)/;
|
|
pp.strictDirective = function(start) {
|
|
var this$1 = this;
|
|
|
|
for (;;) {
|
|
skipWhiteSpace.lastIndex = start;
|
|
start += skipWhiteSpace.exec(this$1.input)[0].length;
|
|
var match = literal.exec(this$1.input.slice(start));
|
|
if (!match) { return false }
|
|
if ((match[1] || match[2]) === "use strict") { return true }
|
|
start += match[0].length;
|
|
}
|
|
};
|
|
|
|
|
|
pp.eat = function(type) {
|
|
if (this.type === type) {
|
|
this.next();
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
};
|
|
|
|
|
|
pp.isContextual = function(name) {
|
|
return this.type === types.name && this.value === name && !this.containsEsc
|
|
};
|
|
|
|
|
|
pp.eatContextual = function(name) {
|
|
if (!this.isContextual(name)) { return false }
|
|
this.next();
|
|
return true
|
|
};
|
|
|
|
|
|
pp.expectContextual = function(name) {
|
|
if (!this.eatContextual(name)) { this.unexpected(); }
|
|
};
|
|
|
|
|
|
pp.canInsertSemicolon = function() {
|
|
return this.type === types.eof ||
|
|
this.type === types.braceR ||
|
|
lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
|
|
};
|
|
|
|
pp.insertSemicolon = function() {
|
|
if (this.canInsertSemicolon()) {
|
|
if (this.options.onInsertedSemicolon)
|
|
{ this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc); }
|
|
return true
|
|
}
|
|
};
|
|
|
|
|
|
pp.semicolon = function() {
|
|
if (!this.eat(types.semi) && !this.insertSemicolon()) { this.unexpected(); }
|
|
};
|
|
|
|
pp.afterTrailingComma = function(tokType, notNext) {
|
|
if (this.type === tokType) {
|
|
if (this.options.onTrailingComma)
|
|
{ this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc); }
|
|
if (!notNext)
|
|
{ this.next(); }
|
|
return true
|
|
}
|
|
};
|
|
|
|
|
|
pp.expect = function(type) {
|
|
this.eat(type) || this.unexpected();
|
|
};
|
|
|
|
|
|
pp.unexpected = function(pos) {
|
|
this.raise(pos != null ? pos : this.start, "Unexpected token");
|
|
};
|
|
|
|
function DestructuringErrors() {
|
|
this.shorthandAssign =
|
|
this.trailingComma =
|
|
this.parenthesizedAssign =
|
|
this.parenthesizedBind =
|
|
this.doubleProto =
|
|
-1;
|
|
}
|
|
|
|
pp.checkPatternErrors = function(refDestructuringErrors, isAssign) {
|
|
if (!refDestructuringErrors) { return }
|
|
if (refDestructuringErrors.trailingComma > -1)
|
|
{ this.raiseRecoverable(refDestructuringErrors.trailingComma, "Comma is not permitted after the rest element"); }
|
|
var parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind;
|
|
if (parens > -1) { this.raiseRecoverable(parens, "Parenthesized pattern"); }
|
|
};
|
|
|
|
pp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
|
|
if (!refDestructuringErrors) { return false }
|
|
var shorthandAssign = refDestructuringErrors.shorthandAssign;
|
|
var doubleProto = refDestructuringErrors.doubleProto;
|
|
if (!andThrow) { return shorthandAssign >= 0 || doubleProto >= 0 }
|
|
if (shorthandAssign >= 0)
|
|
{ this.raise(shorthandAssign, "Shorthand property assignments are valid only in destructuring patterns"); }
|
|
if (doubleProto >= 0)
|
|
{ this.raiseRecoverable(doubleProto, "Redefinition of __proto__ property"); }
|
|
};
|
|
|
|
pp.checkYieldAwaitInDefaultParams = function() {
|
|
if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos))
|
|
{ this.raise(this.yieldPos, "Yield expression cannot be a default value"); }
|
|
if (this.awaitPos)
|
|
{ this.raise(this.awaitPos, "Await expression cannot be a default value"); }
|
|
};
|
|
|
|
pp.isSimpleAssignTarget = function(expr) {
|
|
if (expr.type === "ParenthesizedExpression")
|
|
{ return this.isSimpleAssignTarget(expr.expression) }
|
|
return expr.type === "Identifier" || expr.type === "MemberExpression"
|
|
};
|
|
|
|
var pp$1 = Parser.prototype;
|
|
|
|
|
|
|
|
pp$1.parseTopLevel = function(node) {
|
|
var this$1 = this;
|
|
|
|
var exports = {};
|
|
if (!node.body) { node.body = []; }
|
|
while (this.type !== types.eof) {
|
|
var stmt = this$1.parseStatement(true, true, exports);
|
|
node.body.push(stmt);
|
|
}
|
|
this.adaptDirectivePrologue(node.body);
|
|
this.next();
|
|
if (this.options.ecmaVersion >= 6) {
|
|
node.sourceType = this.options.sourceType;
|
|
}
|
|
return this.finishNode(node, "Program")
|
|
};
|
|
|
|
var loopLabel = {kind: "loop"};
|
|
var switchLabel = {kind: "switch"};
|
|
|
|
pp$1.isLet = function() {
|
|
if (this.options.ecmaVersion < 6 || !this.isContextual("let")) { return false }
|
|
skipWhiteSpace.lastIndex = this.pos;
|
|
var skip = skipWhiteSpace.exec(this.input);
|
|
var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);
|
|
if (nextCh === 91 || nextCh === 123) { return true }
|
|
if (isIdentifierStart(nextCh, true)) {
|
|
var pos = next + 1;
|
|
while (isIdentifierChar(this.input.charCodeAt(pos), true)) { ++pos; }
|
|
var ident = this.input.slice(next, pos);
|
|
if (!keywordRelationalOperator.test(ident)) { return true }
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$1.isAsyncFunction = function() {
|
|
if (this.options.ecmaVersion < 8 || !this.isContextual("async"))
|
|
{ return false }
|
|
|
|
skipWhiteSpace.lastIndex = this.pos;
|
|
var skip = skipWhiteSpace.exec(this.input);
|
|
var next = this.pos + skip[0].length;
|
|
return !lineBreak.test(this.input.slice(this.pos, next)) &&
|
|
this.input.slice(next, next + 8) === "function" &&
|
|
(next + 8 === this.input.length || !isIdentifierChar(this.input.charAt(next + 8)))
|
|
};
|
|
|
|
|
|
pp$1.parseStatement = function(declaration, topLevel, exports) {
|
|
var starttype = this.type, node = this.startNode(), kind;
|
|
|
|
if (this.isLet()) {
|
|
starttype = types._var;
|
|
kind = "let";
|
|
}
|
|
|
|
|
|
switch (starttype) {
|
|
case types._break: case types._continue: return this.parseBreakContinueStatement(node, starttype.keyword)
|
|
case types._debugger: return this.parseDebuggerStatement(node)
|
|
case types._do: return this.parseDoStatement(node)
|
|
case types._for: return this.parseForStatement(node)
|
|
case types._function:
|
|
if (!declaration && this.options.ecmaVersion >= 6) { this.unexpected(); }
|
|
return this.parseFunctionStatement(node, false)
|
|
case types._class:
|
|
if (!declaration) { this.unexpected(); }
|
|
return this.parseClass(node, true)
|
|
case types._if: return this.parseIfStatement(node)
|
|
case types._return: return this.parseReturnStatement(node)
|
|
case types._switch: return this.parseSwitchStatement(node)
|
|
case types._throw: return this.parseThrowStatement(node)
|
|
case types._try: return this.parseTryStatement(node)
|
|
case types._const: case types._var:
|
|
kind = kind || this.value;
|
|
if (!declaration && kind !== "var") { this.unexpected(); }
|
|
return this.parseVarStatement(node, kind)
|
|
case types._while: return this.parseWhileStatement(node)
|
|
case types._with: return this.parseWithStatement(node)
|
|
case types.braceL: return this.parseBlock()
|
|
case types.semi: return this.parseEmptyStatement(node)
|
|
case types._export:
|
|
case types._import:
|
|
if (!this.options.allowImportExportEverywhere) {
|
|
if (!topLevel)
|
|
{ this.raise(this.start, "'import' and 'export' may only appear at the top level"); }
|
|
if (!this.inModule)
|
|
{ this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'"); }
|
|
}
|
|
return starttype === types._import ? this.parseImport(node) : this.parseExport(node, exports)
|
|
|
|
default:
|
|
if (this.isAsyncFunction()) {
|
|
if (!declaration) { this.unexpected(); }
|
|
this.next();
|
|
return this.parseFunctionStatement(node, true)
|
|
}
|
|
|
|
var maybeName = this.value, expr = this.parseExpression();
|
|
if (starttype === types.name && expr.type === "Identifier" && this.eat(types.colon))
|
|
{ return this.parseLabeledStatement(node, maybeName, expr) }
|
|
else { return this.parseExpressionStatement(node, expr) }
|
|
}
|
|
};
|
|
|
|
pp$1.parseBreakContinueStatement = function(node, keyword) {
|
|
var this$1 = this;
|
|
|
|
var isBreak = keyword === "break";
|
|
this.next();
|
|
if (this.eat(types.semi) || this.insertSemicolon()) { node.label = null; }
|
|
else if (this.type !== types.name) { this.unexpected(); }
|
|
else {
|
|
node.label = this.parseIdent();
|
|
this.semicolon();
|
|
}
|
|
|
|
var i = 0;
|
|
for (; i < this.labels.length; ++i) {
|
|
var lab = this$1.labels[i];
|
|
if (node.label == null || lab.name === node.label.name) {
|
|
if (lab.kind != null && (isBreak || lab.kind === "loop")) { break }
|
|
if (node.label && isBreak) { break }
|
|
}
|
|
}
|
|
if (i === this.labels.length) { this.raise(node.start, "Unsyntactic " + keyword); }
|
|
return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement")
|
|
};
|
|
|
|
pp$1.parseDebuggerStatement = function(node) {
|
|
this.next();
|
|
this.semicolon();
|
|
return this.finishNode(node, "DebuggerStatement")
|
|
};
|
|
|
|
pp$1.parseDoStatement = function(node) {
|
|
this.next();
|
|
this.labels.push(loopLabel);
|
|
node.body = this.parseStatement(false);
|
|
this.labels.pop();
|
|
this.expect(types._while);
|
|
node.test = this.parseParenExpression();
|
|
if (this.options.ecmaVersion >= 6)
|
|
{ this.eat(types.semi); }
|
|
else
|
|
{ this.semicolon(); }
|
|
return this.finishNode(node, "DoWhileStatement")
|
|
};
|
|
|
|
|
|
pp$1.parseForStatement = function(node) {
|
|
this.next();
|
|
var awaitAt = (this.options.ecmaVersion >= 9 && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction)) && this.eatContextual("await")) ? this.lastTokStart : -1;
|
|
this.labels.push(loopLabel);
|
|
this.enterLexicalScope();
|
|
this.expect(types.parenL);
|
|
if (this.type === types.semi) {
|
|
if (awaitAt > -1) { this.unexpected(awaitAt); }
|
|
return this.parseFor(node, null)
|
|
}
|
|
var isLet = this.isLet();
|
|
if (this.type === types._var || this.type === types._const || isLet) {
|
|
var init$1 = this.startNode(), kind = isLet ? "let" : this.value;
|
|
this.next();
|
|
this.parseVar(init$1, true, kind);
|
|
this.finishNode(init$1, "VariableDeclaration");
|
|
if ((this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init$1.declarations.length === 1 &&
|
|
!(kind !== "var" && init$1.declarations[0].init)) {
|
|
if (this.options.ecmaVersion >= 9) {
|
|
if (this.type === types._in) {
|
|
if (awaitAt > -1) { this.unexpected(awaitAt); }
|
|
} else { node.await = awaitAt > -1; }
|
|
}
|
|
return this.parseForIn(node, init$1)
|
|
}
|
|
if (awaitAt > -1) { this.unexpected(awaitAt); }
|
|
return this.parseFor(node, init$1)
|
|
}
|
|
var refDestructuringErrors = new DestructuringErrors;
|
|
var init = this.parseExpression(true, refDestructuringErrors);
|
|
if (this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
|
|
if (this.options.ecmaVersion >= 9) {
|
|
if (this.type === types._in) {
|
|
if (awaitAt > -1) { this.unexpected(awaitAt); }
|
|
} else { node.await = awaitAt > -1; }
|
|
}
|
|
this.toAssignable(init, false, refDestructuringErrors);
|
|
this.checkLVal(init);
|
|
return this.parseForIn(node, init)
|
|
} else {
|
|
this.checkExpressionErrors(refDestructuringErrors, true);
|
|
}
|
|
if (awaitAt > -1) { this.unexpected(awaitAt); }
|
|
return this.parseFor(node, init)
|
|
};
|
|
|
|
pp$1.parseFunctionStatement = function(node, isAsync) {
|
|
this.next();
|
|
return this.parseFunction(node, true, false, isAsync)
|
|
};
|
|
|
|
pp$1.parseIfStatement = function(node) {
|
|
this.next();
|
|
node.test = this.parseParenExpression();
|
|
node.consequent = this.parseStatement(!this.strict && this.type === types._function);
|
|
node.alternate = this.eat(types._else) ? this.parseStatement(!this.strict && this.type === types._function) : null;
|
|
return this.finishNode(node, "IfStatement")
|
|
};
|
|
|
|
pp$1.parseReturnStatement = function(node) {
|
|
if (!this.inFunction && !this.options.allowReturnOutsideFunction)
|
|
{ this.raise(this.start, "'return' outside of function"); }
|
|
this.next();
|
|
|
|
|
|
if (this.eat(types.semi) || this.insertSemicolon()) { node.argument = null; }
|
|
else { node.argument = this.parseExpression(); this.semicolon(); }
|
|
return this.finishNode(node, "ReturnStatement")
|
|
};
|
|
|
|
pp$1.parseSwitchStatement = function(node) {
|
|
var this$1 = this;
|
|
|
|
this.next();
|
|
node.discriminant = this.parseParenExpression();
|
|
node.cases = [];
|
|
this.expect(types.braceL);
|
|
this.labels.push(switchLabel);
|
|
this.enterLexicalScope();
|
|
|
|
|
|
var cur;
|
|
for (var sawDefault = false; this.type !== types.braceR;) {
|
|
if (this$1.type === types._case || this$1.type === types._default) {
|
|
var isCase = this$1.type === types._case;
|
|
if (cur) { this$1.finishNode(cur, "SwitchCase"); }
|
|
node.cases.push(cur = this$1.startNode());
|
|
cur.consequent = [];
|
|
this$1.next();
|
|
if (isCase) {
|
|
cur.test = this$1.parseExpression();
|
|
} else {
|
|
if (sawDefault) { this$1.raiseRecoverable(this$1.lastTokStart, "Multiple default clauses"); }
|
|
sawDefault = true;
|
|
cur.test = null;
|
|
}
|
|
this$1.expect(types.colon);
|
|
} else {
|
|
if (!cur) { this$1.unexpected(); }
|
|
cur.consequent.push(this$1.parseStatement(true));
|
|
}
|
|
}
|
|
this.exitLexicalScope();
|
|
if (cur) { this.finishNode(cur, "SwitchCase"); }
|
|
this.next();
|
|
this.labels.pop();
|
|
return this.finishNode(node, "SwitchStatement")
|
|
};
|
|
|
|
pp$1.parseThrowStatement = function(node) {
|
|
this.next();
|
|
if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))
|
|
{ this.raise(this.lastTokEnd, "Illegal newline after throw"); }
|
|
node.argument = this.parseExpression();
|
|
this.semicolon();
|
|
return this.finishNode(node, "ThrowStatement")
|
|
};
|
|
|
|
|
|
var empty = [];
|
|
|
|
pp$1.parseTryStatement = function(node) {
|
|
this.next();
|
|
node.block = this.parseBlock();
|
|
node.handler = null;
|
|
if (this.type === types._catch) {
|
|
var clause = this.startNode();
|
|
this.next();
|
|
if (this.eat(types.parenL)) {
|
|
clause.param = this.parseBindingAtom();
|
|
this.enterLexicalScope();
|
|
this.checkLVal(clause.param, "let");
|
|
this.expect(types.parenR);
|
|
} else {
|
|
if (this.options.ecmaVersion < 10) { this.unexpected(); }
|
|
clause.param = null;
|
|
this.enterLexicalScope();
|
|
}
|
|
clause.body = this.parseBlock(false);
|
|
this.exitLexicalScope();
|
|
node.handler = this.finishNode(clause, "CatchClause");
|
|
}
|
|
node.finalizer = this.eat(types._finally) ? this.parseBlock() : null;
|
|
if (!node.handler && !node.finalizer)
|
|
{ this.raise(node.start, "Missing catch or finally clause"); }
|
|
return this.finishNode(node, "TryStatement")
|
|
};
|
|
|
|
pp$1.parseVarStatement = function(node, kind) {
|
|
this.next();
|
|
this.parseVar(node, false, kind);
|
|
this.semicolon();
|
|
return this.finishNode(node, "VariableDeclaration")
|
|
};
|
|
|
|
pp$1.parseWhileStatement = function(node) {
|
|
this.next();
|
|
node.test = this.parseParenExpression();
|
|
this.labels.push(loopLabel);
|
|
node.body = this.parseStatement(false);
|
|
this.labels.pop();
|
|
return this.finishNode(node, "WhileStatement")
|
|
};
|
|
|
|
pp$1.parseWithStatement = function(node) {
|
|
if (this.strict) { this.raise(this.start, "'with' in strict mode"); }
|
|
this.next();
|
|
node.object = this.parseParenExpression();
|
|
node.body = this.parseStatement(false);
|
|
return this.finishNode(node, "WithStatement")
|
|
};
|
|
|
|
pp$1.parseEmptyStatement = function(node) {
|
|
this.next();
|
|
return this.finishNode(node, "EmptyStatement")
|
|
};
|
|
|
|
pp$1.parseLabeledStatement = function(node, maybeName, expr) {
|
|
var this$1 = this;
|
|
|
|
for (var i$1 = 0, list = this$1.labels; i$1 < list.length; i$1 += 1)
|
|
{
|
|
var label = list[i$1];
|
|
|
|
if (label.name === maybeName)
|
|
{ this$1.raise(expr.start, "Label '" + maybeName + "' is already declared");
|
|
} }
|
|
var kind = this.type.isLoop ? "loop" : this.type === types._switch ? "switch" : null;
|
|
for (var i = this.labels.length - 1; i >= 0; i--) {
|
|
var label$1 = this$1.labels[i];
|
|
if (label$1.statementStart === node.start) {
|
|
label$1.statementStart = this$1.start;
|
|
label$1.kind = kind;
|
|
} else { break }
|
|
}
|
|
this.labels.push({name: maybeName, kind: kind, statementStart: this.start});
|
|
node.body = this.parseStatement(true);
|
|
if (node.body.type === "ClassDeclaration" ||
|
|
node.body.type === "VariableDeclaration" && node.body.kind !== "var" ||
|
|
node.body.type === "FunctionDeclaration" && (this.strict || node.body.generator || node.body.async))
|
|
{ this.raiseRecoverable(node.body.start, "Invalid labeled declaration"); }
|
|
this.labels.pop();
|
|
node.label = expr;
|
|
return this.finishNode(node, "LabeledStatement")
|
|
};
|
|
|
|
pp$1.parseExpressionStatement = function(node, expr) {
|
|
node.expression = expr;
|
|
this.semicolon();
|
|
return this.finishNode(node, "ExpressionStatement")
|
|
};
|
|
|
|
|
|
pp$1.parseBlock = function(createNewLexicalScope) {
|
|
var this$1 = this;
|
|
if ( createNewLexicalScope === void 0 ) createNewLexicalScope = true;
|
|
|
|
var node = this.startNode();
|
|
node.body = [];
|
|
this.expect(types.braceL);
|
|
if (createNewLexicalScope) {
|
|
this.enterLexicalScope();
|
|
}
|
|
while (!this.eat(types.braceR)) {
|
|
var stmt = this$1.parseStatement(true);
|
|
node.body.push(stmt);
|
|
}
|
|
if (createNewLexicalScope) {
|
|
this.exitLexicalScope();
|
|
}
|
|
return this.finishNode(node, "BlockStatement")
|
|
};
|
|
|
|
|
|
pp$1.parseFor = function(node, init) {
|
|
node.init = init;
|
|
this.expect(types.semi);
|
|
node.test = this.type === types.semi ? null : this.parseExpression();
|
|
this.expect(types.semi);
|
|
node.update = this.type === types.parenR ? null : this.parseExpression();
|
|
this.expect(types.parenR);
|
|
this.exitLexicalScope();
|
|
node.body = this.parseStatement(false);
|
|
this.labels.pop();
|
|
return this.finishNode(node, "ForStatement")
|
|
};
|
|
|
|
|
|
pp$1.parseForIn = function(node, init) {
|
|
var type = this.type === types._in ? "ForInStatement" : "ForOfStatement";
|
|
this.next();
|
|
if (type === "ForInStatement") {
|
|
if (init.type === "AssignmentPattern" ||
|
|
(init.type === "VariableDeclaration" && init.declarations[0].init != null &&
|
|
(this.strict || init.declarations[0].id.type !== "Identifier")))
|
|
{ this.raise(init.start, "Invalid assignment in for-in loop head"); }
|
|
}
|
|
node.left = init;
|
|
node.right = type === "ForInStatement" ? this.parseExpression() : this.parseMaybeAssign();
|
|
this.expect(types.parenR);
|
|
this.exitLexicalScope();
|
|
node.body = this.parseStatement(false);
|
|
this.labels.pop();
|
|
return this.finishNode(node, type)
|
|
};
|
|
|
|
|
|
pp$1.parseVar = function(node, isFor, kind) {
|
|
var this$1 = this;
|
|
|
|
node.declarations = [];
|
|
node.kind = kind;
|
|
for (;;) {
|
|
var decl = this$1.startNode();
|
|
this$1.parseVarId(decl, kind);
|
|
if (this$1.eat(types.eq)) {
|
|
decl.init = this$1.parseMaybeAssign(isFor);
|
|
} else if (kind === "const" && !(this$1.type === types._in || (this$1.options.ecmaVersion >= 6 && this$1.isContextual("of")))) {
|
|
this$1.unexpected();
|
|
} else if (decl.id.type !== "Identifier" && !(isFor && (this$1.type === types._in || this$1.isContextual("of")))) {
|
|
this$1.raise(this$1.lastTokEnd, "Complex binding patterns require an initialization value");
|
|
} else {
|
|
decl.init = null;
|
|
}
|
|
node.declarations.push(this$1.finishNode(decl, "VariableDeclarator"));
|
|
if (!this$1.eat(types.comma)) { break }
|
|
}
|
|
return node
|
|
};
|
|
|
|
pp$1.parseVarId = function(decl, kind) {
|
|
decl.id = this.parseBindingAtom(kind);
|
|
this.checkLVal(decl.id, kind, false);
|
|
};
|
|
|
|
|
|
pp$1.parseFunction = function(node, isStatement, allowExpressionBody, isAsync) {
|
|
this.initFunction(node);
|
|
if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync)
|
|
{ node.generator = this.eat(types.star); }
|
|
if (this.options.ecmaVersion >= 8)
|
|
{ node.async = !!isAsync; }
|
|
|
|
if (isStatement) {
|
|
node.id = isStatement === "nullableID" && this.type !== types.name ? null : this.parseIdent();
|
|
if (node.id) {
|
|
this.checkLVal(node.id, this.inModule && !this.inFunction ? "let" : "var");
|
|
}
|
|
}
|
|
|
|
var oldInGen = this.inGenerator, oldInAsync = this.inAsync,
|
|
oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldInFunc = this.inFunction;
|
|
this.inGenerator = node.generator;
|
|
this.inAsync = node.async;
|
|
this.yieldPos = 0;
|
|
this.awaitPos = 0;
|
|
this.inFunction = true;
|
|
this.enterFunctionScope();
|
|
|
|
if (!isStatement)
|
|
{ node.id = this.type === types.name ? this.parseIdent() : null; }
|
|
|
|
this.parseFunctionParams(node);
|
|
this.parseFunctionBody(node, allowExpressionBody);
|
|
|
|
this.inGenerator = oldInGen;
|
|
this.inAsync = oldInAsync;
|
|
this.yieldPos = oldYieldPos;
|
|
this.awaitPos = oldAwaitPos;
|
|
this.inFunction = oldInFunc;
|
|
return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression")
|
|
};
|
|
|
|
pp$1.parseFunctionParams = function(node) {
|
|
this.expect(types.parenL);
|
|
node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
|
|
this.checkYieldAwaitInDefaultParams();
|
|
};
|
|
|
|
|
|
pp$1.parseClass = function(node, isStatement) {
|
|
var this$1 = this;
|
|
|
|
this.next();
|
|
|
|
this.parseClassId(node, isStatement);
|
|
this.parseClassSuper(node);
|
|
var classBody = this.startNode();
|
|
var hadConstructor = false;
|
|
classBody.body = [];
|
|
this.expect(types.braceL);
|
|
while (!this.eat(types.braceR)) {
|
|
var member = this$1.parseClassMember(classBody);
|
|
if (member && member.type === "MethodDefinition" && member.kind === "constructor") {
|
|
if (hadConstructor) { this$1.raise(member.start, "Duplicate constructor in the same class"); }
|
|
hadConstructor = true;
|
|
}
|
|
}
|
|
node.body = this.finishNode(classBody, "ClassBody");
|
|
return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression")
|
|
};
|
|
|
|
pp$1.parseClassMember = function(classBody) {
|
|
var this$1 = this;
|
|
|
|
if (this.eat(types.semi)) { return null }
|
|
|
|
var method = this.startNode();
|
|
var tryContextual = function (k, noLineBreak) {
|
|
if ( noLineBreak === void 0 ) noLineBreak = false;
|
|
|
|
var start = this$1.start, startLoc = this$1.startLoc;
|
|
if (!this$1.eatContextual(k)) { return false }
|
|
if (this$1.type !== types.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) { return true }
|
|
if (method.key) { this$1.unexpected(); }
|
|
method.computed = false;
|
|
method.key = this$1.startNodeAt(start, startLoc);
|
|
method.key.name = k;
|
|
this$1.finishNode(method.key, "Identifier");
|
|
return false
|
|
};
|
|
|
|
method.kind = "method";
|
|
method.static = tryContextual("static");
|
|
var isGenerator = this.eat(types.star);
|
|
var isAsync = false;
|
|
if (!isGenerator) {
|
|
if (this.options.ecmaVersion >= 8 && tryContextual("async", true)) {
|
|
isAsync = true;
|
|
isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);
|
|
} else if (tryContextual("get")) {
|
|
method.kind = "get";
|
|
} else if (tryContextual("set")) {
|
|
method.kind = "set";
|
|
}
|
|
}
|
|
if (!method.key) { this.parsePropertyName(method); }
|
|
var key = method.key;
|
|
if (!method.computed && !method.static && (key.type === "Identifier" && key.name === "constructor" ||
|
|
key.type === "Literal" && key.value === "constructor")) {
|
|
if (method.kind !== "method") { this.raise(key.start, "Constructor can't have get/set modifier"); }
|
|
if (isGenerator) { this.raise(key.start, "Constructor can't be a generator"); }
|
|
if (isAsync) { this.raise(key.start, "Constructor can't be an async method"); }
|
|
method.kind = "constructor";
|
|
} else if (method.static && key.type === "Identifier" && key.name === "prototype") {
|
|
this.raise(key.start, "Classes may not have a static property named prototype");
|
|
}
|
|
this.parseClassMethod(classBody, method, isGenerator, isAsync);
|
|
if (method.kind === "get" && method.value.params.length !== 0)
|
|
{ this.raiseRecoverable(method.value.start, "getter should have no params"); }
|
|
if (method.kind === "set" && method.value.params.length !== 1)
|
|
{ this.raiseRecoverable(method.value.start, "setter should have exactly one param"); }
|
|
if (method.kind === "set" && method.value.params[0].type === "RestElement")
|
|
{ this.raiseRecoverable(method.value.params[0].start, "Setter cannot use rest params"); }
|
|
return method
|
|
};
|
|
|
|
pp$1.parseClassMethod = function(classBody, method, isGenerator, isAsync) {
|
|
method.value = this.parseMethod(isGenerator, isAsync);
|
|
classBody.body.push(this.finishNode(method, "MethodDefinition"));
|
|
};
|
|
|
|
pp$1.parseClassId = function(node, isStatement) {
|
|
node.id = this.type === types.name ? this.parseIdent() : isStatement === true ? this.unexpected() : null;
|
|
};
|
|
|
|
pp$1.parseClassSuper = function(node) {
|
|
node.superClass = this.eat(types._extends) ? this.parseExprSubscripts() : null;
|
|
};
|
|
|
|
|
|
pp$1.parseExport = function(node, exports) {
|
|
var this$1 = this;
|
|
|
|
this.next();
|
|
if (this.eat(types.star)) {
|
|
this.expectContextual("from");
|
|
if (this.type !== types.string) { this.unexpected(); }
|
|
node.source = this.parseExprAtom();
|
|
this.semicolon();
|
|
return this.finishNode(node, "ExportAllDeclaration")
|
|
}
|
|
if (this.eat(types._default)) {
|
|
this.checkExport(exports, "default", this.lastTokStart);
|
|
var isAsync;
|
|
if (this.type === types._function || (isAsync = this.isAsyncFunction())) {
|
|
var fNode = this.startNode();
|
|
this.next();
|
|
if (isAsync) { this.next(); }
|
|
node.declaration = this.parseFunction(fNode, "nullableID", false, isAsync);
|
|
} else if (this.type === types._class) {
|
|
var cNode = this.startNode();
|
|
node.declaration = this.parseClass(cNode, "nullableID");
|
|
} else {
|
|
node.declaration = this.parseMaybeAssign();
|
|
this.semicolon();
|
|
}
|
|
return this.finishNode(node, "ExportDefaultDeclaration")
|
|
}
|
|
if (this.shouldParseExportStatement()) {
|
|
node.declaration = this.parseStatement(true);
|
|
if (node.declaration.type === "VariableDeclaration")
|
|
{ this.checkVariableExport(exports, node.declaration.declarations); }
|
|
else
|
|
{ this.checkExport(exports, node.declaration.id.name, node.declaration.id.start); }
|
|
node.specifiers = [];
|
|
node.source = null;
|
|
} else {
|
|
node.declaration = null;
|
|
node.specifiers = this.parseExportSpecifiers(exports);
|
|
if (this.eatContextual("from")) {
|
|
if (this.type !== types.string) { this.unexpected(); }
|
|
node.source = this.parseExprAtom();
|
|
} else {
|
|
for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
|
|
var spec = list[i];
|
|
|
|
this$1.checkUnreserved(spec.local);
|
|
}
|
|
|
|
node.source = null;
|
|
}
|
|
this.semicolon();
|
|
}
|
|
return this.finishNode(node, "ExportNamedDeclaration")
|
|
};
|
|
|
|
pp$1.checkExport = function(exports, name, pos) {
|
|
if (!exports) { return }
|
|
if (has(exports, name))
|
|
{ this.raiseRecoverable(pos, "Duplicate export '" + name + "'"); }
|
|
exports[name] = true;
|
|
};
|
|
|
|
pp$1.checkPatternExport = function(exports, pat) {
|
|
var this$1 = this;
|
|
|
|
var type = pat.type;
|
|
if (type === "Identifier")
|
|
{ this.checkExport(exports, pat.name, pat.start); }
|
|
else if (type === "ObjectPattern")
|
|
{ for (var i = 0, list = pat.properties; i < list.length; i += 1)
|
|
{
|
|
var prop = list[i];
|
|
|
|
this$1.checkPatternExport(exports, prop);
|
|
} }
|
|
else if (type === "ArrayPattern")
|
|
{ for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) {
|
|
var elt = list$1[i$1];
|
|
|
|
if (elt) { this$1.checkPatternExport(exports, elt); }
|
|
} }
|
|
else if (type === "Property")
|
|
{ this.checkPatternExport(exports, pat.value); }
|
|
else if (type === "AssignmentPattern")
|
|
{ this.checkPatternExport(exports, pat.left); }
|
|
else if (type === "RestElement")
|
|
{ this.checkPatternExport(exports, pat.argument); }
|
|
else if (type === "ParenthesizedExpression")
|
|
{ this.checkPatternExport(exports, pat.expression); }
|
|
};
|
|
|
|
pp$1.checkVariableExport = function(exports, decls) {
|
|
var this$1 = this;
|
|
|
|
if (!exports) { return }
|
|
for (var i = 0, list = decls; i < list.length; i += 1)
|
|
{
|
|
var decl = list[i];
|
|
|
|
this$1.checkPatternExport(exports, decl.id);
|
|
}
|
|
};
|
|
|
|
pp$1.shouldParseExportStatement = function() {
|
|
return this.type.keyword === "var" ||
|
|
this.type.keyword === "const" ||
|
|
this.type.keyword === "class" ||
|
|
this.type.keyword === "function" ||
|
|
this.isLet() ||
|
|
this.isAsyncFunction()
|
|
};
|
|
|
|
|
|
pp$1.parseExportSpecifiers = function(exports) {
|
|
var this$1 = this;
|
|
|
|
var nodes = [], first = true;
|
|
this.expect(types.braceL);
|
|
while (!this.eat(types.braceR)) {
|
|
if (!first) {
|
|
this$1.expect(types.comma);
|
|
if (this$1.afterTrailingComma(types.braceR)) { break }
|
|
} else { first = false; }
|
|
|
|
var node = this$1.startNode();
|
|
node.local = this$1.parseIdent(true);
|
|
node.exported = this$1.eatContextual("as") ? this$1.parseIdent(true) : node.local;
|
|
this$1.checkExport(exports, node.exported.name, node.exported.start);
|
|
nodes.push(this$1.finishNode(node, "ExportSpecifier"));
|
|
}
|
|
return nodes
|
|
};
|
|
|
|
|
|
pp$1.parseImport = function(node) {
|
|
this.next();
|
|
if (this.type === types.string) {
|
|
node.specifiers = empty;
|
|
node.source = this.parseExprAtom();
|
|
} else {
|
|
node.specifiers = this.parseImportSpecifiers();
|
|
this.expectContextual("from");
|
|
node.source = this.type === types.string ? this.parseExprAtom() : this.unexpected();
|
|
}
|
|
this.semicolon();
|
|
return this.finishNode(node, "ImportDeclaration")
|
|
};
|
|
|
|
|
|
pp$1.parseImportSpecifiers = function() {
|
|
var this$1 = this;
|
|
|
|
var nodes = [], first = true;
|
|
if (this.type === types.name) {
|
|
var node = this.startNode();
|
|
node.local = this.parseIdent();
|
|
this.checkLVal(node.local, "let");
|
|
nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
|
|
if (!this.eat(types.comma)) { return nodes }
|
|
}
|
|
if (this.type === types.star) {
|
|
var node$1 = this.startNode();
|
|
this.next();
|
|
this.expectContextual("as");
|
|
node$1.local = this.parseIdent();
|
|
this.checkLVal(node$1.local, "let");
|
|
nodes.push(this.finishNode(node$1, "ImportNamespaceSpecifier"));
|
|
return nodes
|
|
}
|
|
this.expect(types.braceL);
|
|
while (!this.eat(types.braceR)) {
|
|
if (!first) {
|
|
this$1.expect(types.comma);
|
|
if (this$1.afterTrailingComma(types.braceR)) { break }
|
|
} else { first = false; }
|
|
|
|
var node$2 = this$1.startNode();
|
|
node$2.imported = this$1.parseIdent(true);
|
|
if (this$1.eatContextual("as")) {
|
|
node$2.local = this$1.parseIdent();
|
|
} else {
|
|
this$1.checkUnreserved(node$2.imported);
|
|
node$2.local = node$2.imported;
|
|
}
|
|
this$1.checkLVal(node$2.local, "let");
|
|
nodes.push(this$1.finishNode(node$2, "ImportSpecifier"));
|
|
}
|
|
return nodes
|
|
};
|
|
|
|
pp$1.adaptDirectivePrologue = function(statements) {
|
|
for (var i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) {
|
|
statements[i].directive = statements[i].expression.raw.slice(1, -1);
|
|
}
|
|
};
|
|
pp$1.isDirectiveCandidate = function(statement) {
|
|
return (
|
|
statement.type === "ExpressionStatement" &&
|
|
statement.expression.type === "Literal" &&
|
|
typeof statement.expression.value === "string" &&
|
|
(this.input[statement.start] === "\"" || this.input[statement.start] === "'")
|
|
)
|
|
};
|
|
|
|
var pp$2 = Parser.prototype;
|
|
|
|
|
|
pp$2.toAssignable = function(node, isBinding, refDestructuringErrors) {
|
|
var this$1 = this;
|
|
|
|
if (this.options.ecmaVersion >= 6 && node) {
|
|
switch (node.type) {
|
|
case "Identifier":
|
|
if (this.inAsync && node.name === "await")
|
|
{ this.raise(node.start, "Can not use 'await' as identifier inside an async function"); }
|
|
break
|
|
|
|
case "ObjectPattern":
|
|
case "ArrayPattern":
|
|
case "RestElement":
|
|
break
|
|
|
|
case "ObjectExpression":
|
|
node.type = "ObjectPattern";
|
|
if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
|
|
for (var i = 0, list = node.properties; i < list.length; i += 1) {
|
|
var prop = list[i];
|
|
|
|
this$1.toAssignable(prop, isBinding);
|
|
if (
|
|
prop.type === "RestElement" &&
|
|
(prop.argument.type === "ArrayPattern" || prop.argument.type === "ObjectPattern")
|
|
) {
|
|
this$1.raise(prop.argument.start, "Unexpected token");
|
|
}
|
|
}
|
|
break
|
|
|
|
case "Property":
|
|
if (node.kind !== "init") { this.raise(node.key.start, "Object pattern can't contain getter or setter"); }
|
|
this.toAssignable(node.value, isBinding);
|
|
break
|
|
|
|
case "ArrayExpression":
|
|
node.type = "ArrayPattern";
|
|
if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
|
|
this.toAssignableList(node.elements, isBinding);
|
|
break
|
|
|
|
case "SpreadElement":
|
|
node.type = "RestElement";
|
|
this.toAssignable(node.argument, isBinding);
|
|
if (node.argument.type === "AssignmentPattern")
|
|
{ this.raise(node.argument.start, "Rest elements cannot have a default value"); }
|
|
break
|
|
|
|
case "AssignmentExpression":
|
|
if (node.operator !== "=") { this.raise(node.left.end, "Only '=' operator can be used for specifying default value."); }
|
|
node.type = "AssignmentPattern";
|
|
delete node.operator;
|
|
this.toAssignable(node.left, isBinding);
|
|
|
|
case "AssignmentPattern":
|
|
break
|
|
|
|
case "ParenthesizedExpression":
|
|
this.toAssignable(node.expression, isBinding);
|
|
break
|
|
|
|
case "MemberExpression":
|
|
if (!isBinding) { break }
|
|
|
|
default:
|
|
this.raise(node.start, "Assigning to rvalue");
|
|
}
|
|
} else if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }
|
|
return node
|
|
};
|
|
|
|
|
|
pp$2.toAssignableList = function(exprList, isBinding) {
|
|
var this$1 = this;
|
|
|
|
var end = exprList.length;
|
|
for (var i = 0; i < end; i++) {
|
|
var elt = exprList[i];
|
|
if (elt) { this$1.toAssignable(elt, isBinding); }
|
|
}
|
|
if (end) {
|
|
var last = exprList[end - 1];
|
|
if (this.options.ecmaVersion === 6 && isBinding && last && last.type === "RestElement" && last.argument.type !== "Identifier")
|
|
{ this.unexpected(last.argument.start); }
|
|
}
|
|
return exprList
|
|
};
|
|
|
|
|
|
pp$2.parseSpread = function(refDestructuringErrors) {
|
|
var node = this.startNode();
|
|
this.next();
|
|
node.argument = this.parseMaybeAssign(false, refDestructuringErrors);
|
|
return this.finishNode(node, "SpreadElement")
|
|
};
|
|
|
|
pp$2.parseRestBinding = function() {
|
|
var node = this.startNode();
|
|
this.next();
|
|
|
|
if (this.options.ecmaVersion === 6 && this.type !== types.name)
|
|
{ this.unexpected(); }
|
|
|
|
node.argument = this.parseBindingAtom();
|
|
|
|
return this.finishNode(node, "RestElement")
|
|
};
|
|
|
|
|
|
pp$2.parseBindingAtom = function() {
|
|
if (this.options.ecmaVersion >= 6) {
|
|
switch (this.type) {
|
|
case types.bracketL:
|
|
var node = this.startNode();
|
|
this.next();
|
|
node.elements = this.parseBindingList(types.bracketR, true, true);
|
|
return this.finishNode(node, "ArrayPattern")
|
|
|
|
case types.braceL:
|
|
return this.parseObj(true)
|
|
}
|
|
}
|
|
return this.parseIdent()
|
|
};
|
|
|
|
pp$2.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
|
|
var this$1 = this;
|
|
|
|
var elts = [], first = true;
|
|
while (!this.eat(close)) {
|
|
if (first) { first = false; }
|
|
else { this$1.expect(types.comma); }
|
|
if (allowEmpty && this$1.type === types.comma) {
|
|
elts.push(null);
|
|
} else if (allowTrailingComma && this$1.afterTrailingComma(close)) {
|
|
break
|
|
} else if (this$1.type === types.ellipsis) {
|
|
var rest = this$1.parseRestBinding();
|
|
this$1.parseBindingListItem(rest);
|
|
elts.push(rest);
|
|
if (this$1.type === types.comma) { this$1.raise(this$1.start, "Comma is not permitted after the rest element"); }
|
|
this$1.expect(close);
|
|
break
|
|
} else {
|
|
var elem = this$1.parseMaybeDefault(this$1.start, this$1.startLoc);
|
|
this$1.parseBindingListItem(elem);
|
|
elts.push(elem);
|
|
}
|
|
}
|
|
return elts
|
|
};
|
|
|
|
pp$2.parseBindingListItem = function(param) {
|
|
return param
|
|
};
|
|
|
|
|
|
pp$2.parseMaybeDefault = function(startPos, startLoc, left) {
|
|
left = left || this.parseBindingAtom();
|
|
if (this.options.ecmaVersion < 6 || !this.eat(types.eq)) { return left }
|
|
var node = this.startNodeAt(startPos, startLoc);
|
|
node.left = left;
|
|
node.right = this.parseMaybeAssign();
|
|
return this.finishNode(node, "AssignmentPattern")
|
|
};
|
|
|
|
|
|
pp$2.checkLVal = function(expr, bindingType, checkClashes) {
|
|
var this$1 = this;
|
|
|
|
switch (expr.type) {
|
|
case "Identifier":
|
|
if (this.strict && this.reservedWordsStrictBind.test(expr.name))
|
|
{ this.raiseRecoverable(expr.start, (bindingType ? "Binding " : "Assigning to ") + expr.name + " in strict mode"); }
|
|
if (checkClashes) {
|
|
if (has(checkClashes, expr.name))
|
|
{ this.raiseRecoverable(expr.start, "Argument name clash"); }
|
|
checkClashes[expr.name] = true;
|
|
}
|
|
if (bindingType && bindingType !== "none") {
|
|
if (
|
|
bindingType === "var" && !this.canDeclareVarName(expr.name) ||
|
|
bindingType !== "var" && !this.canDeclareLexicalName(expr.name)
|
|
) {
|
|
this.raiseRecoverable(expr.start, ("Identifier '" + (expr.name) + "' has already been declared"));
|
|
}
|
|
if (bindingType === "var") {
|
|
this.declareVarName(expr.name);
|
|
} else {
|
|
this.declareLexicalName(expr.name);
|
|
}
|
|
}
|
|
break
|
|
|
|
case "MemberExpression":
|
|
if (bindingType) { this.raiseRecoverable(expr.start, "Binding member expression"); }
|
|
break
|
|
|
|
case "ObjectPattern":
|
|
for (var i = 0, list = expr.properties; i < list.length; i += 1)
|
|
{
|
|
var prop = list[i];
|
|
|
|
this$1.checkLVal(prop, bindingType, checkClashes);
|
|
}
|
|
break
|
|
|
|
case "Property":
|
|
this.checkLVal(expr.value, bindingType, checkClashes);
|
|
break
|
|
|
|
case "ArrayPattern":
|
|
for (var i$1 = 0, list$1 = expr.elements; i$1 < list$1.length; i$1 += 1) {
|
|
var elem = list$1[i$1];
|
|
|
|
if (elem) { this$1.checkLVal(elem, bindingType, checkClashes); }
|
|
}
|
|
break
|
|
|
|
case "AssignmentPattern":
|
|
this.checkLVal(expr.left, bindingType, checkClashes);
|
|
break
|
|
|
|
case "RestElement":
|
|
this.checkLVal(expr.argument, bindingType, checkClashes);
|
|
break
|
|
|
|
case "ParenthesizedExpression":
|
|
this.checkLVal(expr.expression, bindingType, checkClashes);
|
|
break
|
|
|
|
default:
|
|
this.raise(expr.start, (bindingType ? "Binding" : "Assigning to") + " rvalue");
|
|
}
|
|
};
|
|
|
|
|
|
var pp$3 = Parser.prototype;
|
|
|
|
|
|
pp$3.checkPropClash = function(prop, propHash, refDestructuringErrors) {
|
|
if (this.options.ecmaVersion >= 9 && prop.type === "SpreadElement")
|
|
{ return }
|
|
if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))
|
|
{ return }
|
|
var key = prop.key;
|
|
var name;
|
|
switch (key.type) {
|
|
case "Identifier": name = key.name; break
|
|
case "Literal": name = String(key.value); break
|
|
default: return
|
|
}
|
|
var kind = prop.kind;
|
|
if (this.options.ecmaVersion >= 6) {
|
|
if (name === "__proto__" && kind === "init") {
|
|
if (propHash.proto) {
|
|
if (refDestructuringErrors && refDestructuringErrors.doubleProto < 0) { refDestructuringErrors.doubleProto = key.start; }
|
|
else { this.raiseRecoverable(key.start, "Redefinition of __proto__ property"); }
|
|
}
|
|
propHash.proto = true;
|
|
}
|
|
return
|
|
}
|
|
name = "$" + name;
|
|
var other = propHash[name];
|
|
if (other) {
|
|
var redefinition;
|
|
if (kind === "init") {
|
|
redefinition = this.strict && other.init || other.get || other.set;
|
|
} else {
|
|
redefinition = other.init || other[kind];
|
|
}
|
|
if (redefinition)
|
|
{ this.raiseRecoverable(key.start, "Redefinition of property"); }
|
|
} else {
|
|
other = propHash[name] = {
|
|
init: false,
|
|
get: false,
|
|
set: false
|
|
};
|
|
}
|
|
other[kind] = true;
|
|
};
|
|
|
|
|
|
|
|
|
|
pp$3.parseExpression = function(noIn, refDestructuringErrors) {
|
|
var this$1 = this;
|
|
|
|
var startPos = this.start, startLoc = this.startLoc;
|
|
var expr = this.parseMaybeAssign(noIn, refDestructuringErrors);
|
|
if (this.type === types.comma) {
|
|
var node = this.startNodeAt(startPos, startLoc);
|
|
node.expressions = [expr];
|
|
while (this.eat(types.comma)) { node.expressions.push(this$1.parseMaybeAssign(noIn, refDestructuringErrors)); }
|
|
return this.finishNode(node, "SequenceExpression")
|
|
}
|
|
return expr
|
|
};
|
|
|
|
|
|
pp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {
|
|
if (this.inGenerator && this.isContextual("yield")) { return this.parseYield() }
|
|
|
|
var ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1;
|
|
if (refDestructuringErrors) {
|
|
oldParenAssign = refDestructuringErrors.parenthesizedAssign;
|
|
oldTrailingComma = refDestructuringErrors.trailingComma;
|
|
refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = -1;
|
|
} else {
|
|
refDestructuringErrors = new DestructuringErrors;
|
|
ownDestructuringErrors = true;
|
|
}
|
|
|
|
var startPos = this.start, startLoc = this.startLoc;
|
|
if (this.type === types.parenL || this.type === types.name)
|
|
{ this.potentialArrowAt = this.start; }
|
|
var left = this.parseMaybeConditional(noIn, refDestructuringErrors);
|
|
if (afterLeftParse) { left = afterLeftParse.call(this, left, startPos, startLoc); }
|
|
if (this.type.isAssign) {
|
|
var node = this.startNodeAt(startPos, startLoc);
|
|
node.operator = this.value;
|
|
node.left = this.type === types.eq ? this.toAssignable(left, false, refDestructuringErrors) : left;
|
|
if (!ownDestructuringErrors) { DestructuringErrors.call(refDestructuringErrors); }
|
|
refDestructuringErrors.shorthandAssign = -1;
|
|
this.checkLVal(left);
|
|
this.next();
|
|
node.right = this.parseMaybeAssign(noIn);
|
|
return this.finishNode(node, "AssignmentExpression")
|
|
} else {
|
|
if (ownDestructuringErrors) { this.checkExpressionErrors(refDestructuringErrors, true); }
|
|
}
|
|
if (oldParenAssign > -1) { refDestructuringErrors.parenthesizedAssign = oldParenAssign; }
|
|
if (oldTrailingComma > -1) { refDestructuringErrors.trailingComma = oldTrailingComma; }
|
|
return left
|
|
};
|
|
|
|
|
|
pp$3.parseMaybeConditional = function(noIn, refDestructuringErrors) {
|
|
var startPos = this.start, startLoc = this.startLoc;
|
|
var expr = this.parseExprOps(noIn, refDestructuringErrors);
|
|
if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
|
|
if (this.eat(types.question)) {
|
|
var node = this.startNodeAt(startPos, startLoc);
|
|
node.test = expr;
|
|
node.consequent = this.parseMaybeAssign();
|
|
this.expect(types.colon);
|
|
node.alternate = this.parseMaybeAssign(noIn);
|
|
return this.finishNode(node, "ConditionalExpression")
|
|
}
|
|
return expr
|
|
};
|
|
|
|
|
|
pp$3.parseExprOps = function(noIn, refDestructuringErrors) {
|
|
var startPos = this.start, startLoc = this.startLoc;
|
|
var expr = this.parseMaybeUnary(refDestructuringErrors, false);
|
|
if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
|
|
return expr.start === startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, noIn)
|
|
};
|
|
|
|
|
|
pp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
|
|
var prec = this.type.binop;
|
|
if (prec != null && (!noIn || this.type !== types._in)) {
|
|
if (prec > minPrec) {
|
|
var logical = this.type === types.logicalOR || this.type === types.logicalAND;
|
|
var op = this.value;
|
|
this.next();
|
|
var startPos = this.start, startLoc = this.startLoc;
|
|
var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn);
|
|
var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical);
|
|
return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)
|
|
}
|
|
}
|
|
return left
|
|
};
|
|
|
|
pp$3.buildBinary = function(startPos, startLoc, left, right, op, logical) {
|
|
var node = this.startNodeAt(startPos, startLoc);
|
|
node.left = left;
|
|
node.operator = op;
|
|
node.right = right;
|
|
return this.finishNode(node, logical ? "LogicalExpression" : "BinaryExpression")
|
|
};
|
|
|
|
|
|
pp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {
|
|
var this$1 = this;
|
|
|
|
var startPos = this.start, startLoc = this.startLoc, expr;
|
|
if (this.isContextual("await") && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction))) {
|
|
expr = this.parseAwait();
|
|
sawUnary = true;
|
|
} else if (this.type.prefix) {
|
|
var node = this.startNode(), update = this.type === types.incDec;
|
|
node.operator = this.value;
|
|
node.prefix = true;
|
|
this.next();
|
|
node.argument = this.parseMaybeUnary(null, true);
|
|
this.checkExpressionErrors(refDestructuringErrors, true);
|
|
if (update) { this.checkLVal(node.argument); }
|
|
else if (this.strict && node.operator === "delete" &&
|
|
node.argument.type === "Identifier")
|
|
{ this.raiseRecoverable(node.start, "Deleting local variable in strict mode"); }
|
|
else { sawUnary = true; }
|
|
expr = this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
|
|
} else {
|
|
expr = this.parseExprSubscripts(refDestructuringErrors);
|
|
if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
|
|
while (this.type.postfix && !this.canInsertSemicolon()) {
|
|
var node$1 = this$1.startNodeAt(startPos, startLoc);
|
|
node$1.operator = this$1.value;
|
|
node$1.prefix = false;
|
|
node$1.argument = expr;
|
|
this$1.checkLVal(expr);
|
|
this$1.next();
|
|
expr = this$1.finishNode(node$1, "UpdateExpression");
|
|
}
|
|
}
|
|
|
|
if (!sawUnary && this.eat(types.starstar))
|
|
{ return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), "**", false) }
|
|
else
|
|
{ return expr }
|
|
};
|
|
|
|
|
|
pp$3.parseExprSubscripts = function(refDestructuringErrors) {
|
|
var startPos = this.start, startLoc = this.startLoc;
|
|
var expr = this.parseExprAtom(refDestructuringErrors);
|
|
var skipArrowSubscripts = expr.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== ")";
|
|
if (this.checkExpressionErrors(refDestructuringErrors) || skipArrowSubscripts) { return expr }
|
|
var result = this.parseSubscripts(expr, startPos, startLoc);
|
|
if (refDestructuringErrors && result.type === "MemberExpression") {
|
|
if (refDestructuringErrors.parenthesizedAssign >= result.start) { refDestructuringErrors.parenthesizedAssign = -1; }
|
|
if (refDestructuringErrors.parenthesizedBind >= result.start) { refDestructuringErrors.parenthesizedBind = -1; }
|
|
}
|
|
return result
|
|
};
|
|
|
|
pp$3.parseSubscripts = function(base, startPos, startLoc, noCalls) {
|
|
var this$1 = this;
|
|
|
|
var maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === "Identifier" && base.name === "async" &&
|
|
this.lastTokEnd === base.end && !this.canInsertSemicolon() && this.input.slice(base.start, base.end) === "async";
|
|
for (var computed = (void 0);;) {
|
|
if ((computed = this$1.eat(types.bracketL)) || this$1.eat(types.dot)) {
|
|
var node = this$1.startNodeAt(startPos, startLoc);
|
|
node.object = base;
|
|
node.property = computed ? this$1.parseExpression() : this$1.parseIdent(true);
|
|
node.computed = !!computed;
|
|
if (computed) { this$1.expect(types.bracketR); }
|
|
base = this$1.finishNode(node, "MemberExpression");
|
|
} else if (!noCalls && this$1.eat(types.parenL)) {
|
|
var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this$1.yieldPos, oldAwaitPos = this$1.awaitPos;
|
|
this$1.yieldPos = 0;
|
|
this$1.awaitPos = 0;
|
|
var exprList = this$1.parseExprList(types.parenR, this$1.options.ecmaVersion >= 8, false, refDestructuringErrors);
|
|
if (maybeAsyncArrow && !this$1.canInsertSemicolon() && this$1.eat(types.arrow)) {
|
|
this$1.checkPatternErrors(refDestructuringErrors, false);
|
|
this$1.checkYieldAwaitInDefaultParams();
|
|
this$1.yieldPos = oldYieldPos;
|
|
this$1.awaitPos = oldAwaitPos;
|
|
return this$1.parseArrowExpression(this$1.startNodeAt(startPos, startLoc), exprList, true)
|
|
}
|
|
this$1.checkExpressionErrors(refDestructuringErrors, true);
|
|
this$1.yieldPos = oldYieldPos || this$1.yieldPos;
|
|
this$1.awaitPos = oldAwaitPos || this$1.awaitPos;
|
|
var node$1 = this$1.startNodeAt(startPos, startLoc);
|
|
node$1.callee = base;
|
|
node$1.arguments = exprList;
|
|
base = this$1.finishNode(node$1, "CallExpression");
|
|
} else if (this$1.type === types.backQuote) {
|
|
var node$2 = this$1.startNodeAt(startPos, startLoc);
|
|
node$2.tag = base;
|
|
node$2.quasi = this$1.parseTemplate({isTagged: true});
|
|
base = this$1.finishNode(node$2, "TaggedTemplateExpression");
|
|
} else {
|
|
return base
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
pp$3.parseExprAtom = function(refDestructuringErrors) {
|
|
var node, canBeArrow = this.potentialArrowAt === this.start;
|
|
switch (this.type) {
|
|
case types._super:
|
|
if (!this.inFunction)
|
|
{ this.raise(this.start, "'super' outside of function or class"); }
|
|
node = this.startNode();
|
|
this.next();
|
|
if (this.type !== types.dot && this.type !== types.bracketL && this.type !== types.parenL)
|
|
{ this.unexpected(); }
|
|
return this.finishNode(node, "Super")
|
|
|
|
case types._this:
|
|
node = this.startNode();
|
|
this.next();
|
|
return this.finishNode(node, "ThisExpression")
|
|
|
|
case types.name:
|
|
var startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc;
|
|
var id = this.parseIdent(this.type !== types.name);
|
|
if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === "async" && !this.canInsertSemicolon() && this.eat(types._function))
|
|
{ return this.parseFunction(this.startNodeAt(startPos, startLoc), false, false, true) }
|
|
if (canBeArrow && !this.canInsertSemicolon()) {
|
|
if (this.eat(types.arrow))
|
|
{ return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false) }
|
|
if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types.name && !containsEsc) {
|
|
id = this.parseIdent();
|
|
if (this.canInsertSemicolon() || !this.eat(types.arrow))
|
|
{ this.unexpected(); }
|
|
return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true)
|
|
}
|
|
}
|
|
return id
|
|
|
|
case types.regexp:
|
|
var value = this.value;
|
|
node = this.parseLiteral(value.value);
|
|
node.regex = {pattern: value.pattern, flags: value.flags};
|
|
return node
|
|
|
|
case types.num: case types.string:
|
|
return this.parseLiteral(this.value)
|
|
|
|
case types._null: case types._true: case types._false:
|
|
node = this.startNode();
|
|
node.value = this.type === types._null ? null : this.type === types._true;
|
|
node.raw = this.type.keyword;
|
|
this.next();
|
|
return this.finishNode(node, "Literal")
|
|
|
|
case types.parenL:
|
|
var start = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow);
|
|
if (refDestructuringErrors) {
|
|
if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr))
|
|
{ refDestructuringErrors.parenthesizedAssign = start; }
|
|
if (refDestructuringErrors.parenthesizedBind < 0)
|
|
{ refDestructuringErrors.parenthesizedBind = start; }
|
|
}
|
|
return expr
|
|
|
|
case types.bracketL:
|
|
node = this.startNode();
|
|
this.next();
|
|
node.elements = this.parseExprList(types.bracketR, true, true, refDestructuringErrors);
|
|
return this.finishNode(node, "ArrayExpression")
|
|
|
|
case types.braceL:
|
|
return this.parseObj(false, refDestructuringErrors)
|
|
|
|
case types._function:
|
|
node = this.startNode();
|
|
this.next();
|
|
return this.parseFunction(node, false)
|
|
|
|
case types._class:
|
|
return this.parseClass(this.startNode(), false)
|
|
|
|
case types._new:
|
|
return this.parseNew()
|
|
|
|
case types.backQuote:
|
|
return this.parseTemplate()
|
|
|
|
default:
|
|
this.unexpected();
|
|
}
|
|
};
|
|
|
|
pp$3.parseLiteral = function(value) {
|
|
var node = this.startNode();
|
|
node.value = value;
|
|
node.raw = this.input.slice(this.start, this.end);
|
|
this.next();
|
|
return this.finishNode(node, "Literal")
|
|
};
|
|
|
|
pp$3.parseParenExpression = function() {
|
|
this.expect(types.parenL);
|
|
var val = this.parseExpression();
|
|
this.expect(types.parenR);
|
|
return val
|
|
};
|
|
|
|
pp$3.parseParenAndDistinguishExpression = function(canBeArrow) {
|
|
var this$1 = this;
|
|
|
|
var startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8;
|
|
if (this.options.ecmaVersion >= 6) {
|
|
this.next();
|
|
|
|
var innerStartPos = this.start, innerStartLoc = this.startLoc;
|
|
var exprList = [], first = true, lastIsComma = false;
|
|
var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart;
|
|
this.yieldPos = 0;
|
|
this.awaitPos = 0;
|
|
while (this.type !== types.parenR) {
|
|
first ? first = false : this$1.expect(types.comma);
|
|
if (allowTrailingComma && this$1.afterTrailingComma(types.parenR, true)) {
|
|
lastIsComma = true;
|
|
break
|
|
} else if (this$1.type === types.ellipsis) {
|
|
spreadStart = this$1.start;
|
|
exprList.push(this$1.parseParenItem(this$1.parseRestBinding()));
|
|
if (this$1.type === types.comma) { this$1.raise(this$1.start, "Comma is not permitted after the rest element"); }
|
|
break
|
|
} else {
|
|
exprList.push(this$1.parseMaybeAssign(false, refDestructuringErrors, this$1.parseParenItem));
|
|
}
|
|
}
|
|
var innerEndPos = this.start, innerEndLoc = this.startLoc;
|
|
this.expect(types.parenR);
|
|
|
|
if (canBeArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {
|
|
this.checkPatternErrors(refDestructuringErrors, false);
|
|
this.checkYieldAwaitInDefaultParams();
|
|
this.yieldPos = oldYieldPos;
|
|
this.awaitPos = oldAwaitPos;
|
|
return this.parseParenArrowList(startPos, startLoc, exprList)
|
|
}
|
|
|
|
if (!exprList.length || lastIsComma) { this.unexpected(this.lastTokStart); }
|
|
if (spreadStart) { this.unexpected(spreadStart); }
|
|
this.checkExpressionErrors(refDestructuringErrors, true);
|
|
this.yieldPos = oldYieldPos || this.yieldPos;
|
|
this.awaitPos = oldAwaitPos || this.awaitPos;
|
|
|
|
if (exprList.length > 1) {
|
|
val = this.startNodeAt(innerStartPos, innerStartLoc);
|
|
val.expressions = exprList;
|
|
this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc);
|
|
} else {
|
|
val = exprList[0];
|
|
}
|
|
} else {
|
|
val = this.parseParenExpression();
|
|
}
|
|
|
|
if (this.options.preserveParens) {
|
|
var par = this.startNodeAt(startPos, startLoc);
|
|
par.expression = val;
|
|
return this.finishNode(par, "ParenthesizedExpression")
|
|
} else {
|
|
return val
|
|
}
|
|
};
|
|
|
|
pp$3.parseParenItem = function(item) {
|
|
return item
|
|
};
|
|
|
|
pp$3.parseParenArrowList = function(startPos, startLoc, exprList) {
|
|
return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList)
|
|
};
|
|
|
|
|
|
var empty$1 = [];
|
|
|
|
pp$3.parseNew = function() {
|
|
var node = this.startNode();
|
|
var meta = this.parseIdent(true);
|
|
if (this.options.ecmaVersion >= 6 && this.eat(types.dot)) {
|
|
node.meta = meta;
|
|
var containsEsc = this.containsEsc;
|
|
node.property = this.parseIdent(true);
|
|
if (node.property.name !== "target" || containsEsc)
|
|
{ this.raiseRecoverable(node.property.start, "The only valid meta property for new is new.target"); }
|
|
if (!this.inFunction)
|
|
{ this.raiseRecoverable(node.start, "new.target can only be used in functions"); }
|
|
return this.finishNode(node, "MetaProperty")
|
|
}
|
|
var startPos = this.start, startLoc = this.startLoc;
|
|
node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);
|
|
if (this.eat(types.parenL)) { node.arguments = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8, false); }
|
|
else { node.arguments = empty$1; }
|
|
return this.finishNode(node, "NewExpression")
|
|
};
|
|
|
|
|
|
pp$3.parseTemplateElement = function(ref) {
|
|
var isTagged = ref.isTagged;
|
|
|
|
var elem = this.startNode();
|
|
if (this.type === types.invalidTemplate) {
|
|
if (!isTagged) {
|
|
this.raiseRecoverable(this.start, "Bad escape sequence in untagged template literal");
|
|
}
|
|
elem.value = {
|
|
raw: this.value,
|
|
cooked: null
|
|
};
|
|
} else {
|
|
elem.value = {
|
|
raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, "\n"),
|
|
cooked: this.value
|
|
};
|
|
}
|
|
this.next();
|
|
elem.tail = this.type === types.backQuote;
|
|
return this.finishNode(elem, "TemplateElement")
|
|
};
|
|
|
|
pp$3.parseTemplate = function(ref) {
|
|
var this$1 = this;
|
|
if ( ref === void 0 ) ref = {};
|
|
var isTagged = ref.isTagged; if ( isTagged === void 0 ) isTagged = false;
|
|
|
|
var node = this.startNode();
|
|
this.next();
|
|
node.expressions = [];
|
|
var curElt = this.parseTemplateElement({isTagged: isTagged});
|
|
node.quasis = [curElt];
|
|
while (!curElt.tail) {
|
|
if (this$1.type === types.eof) { this$1.raise(this$1.pos, "Unterminated template literal"); }
|
|
this$1.expect(types.dollarBraceL);
|
|
node.expressions.push(this$1.parseExpression());
|
|
this$1.expect(types.braceR);
|
|
node.quasis.push(curElt = this$1.parseTemplateElement({isTagged: isTagged}));
|
|
}
|
|
this.next();
|
|
return this.finishNode(node, "TemplateLiteral")
|
|
};
|
|
|
|
pp$3.isAsyncProp = function(prop) {
|
|
return !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" &&
|
|
(this.type === types.name || this.type === types.num || this.type === types.string || this.type === types.bracketL || this.type.keyword || (this.options.ecmaVersion >= 9 && this.type === types.star)) &&
|
|
!lineBreak.test(this.input.slice(this.lastTokEnd, this.start))
|
|
};
|
|
|
|
|
|
pp$3.parseObj = function(isPattern, refDestructuringErrors) {
|
|
var this$1 = this;
|
|
|
|
var node = this.startNode(), first = true, propHash = {};
|
|
node.properties = [];
|
|
this.next();
|
|
while (!this.eat(types.braceR)) {
|
|
if (!first) {
|
|
this$1.expect(types.comma);
|
|
if (this$1.afterTrailingComma(types.braceR)) { break }
|
|
} else { first = false; }
|
|
|
|
var prop = this$1.parseProperty(isPattern, refDestructuringErrors);
|
|
if (!isPattern) { this$1.checkPropClash(prop, propHash, refDestructuringErrors); }
|
|
node.properties.push(prop);
|
|
}
|
|
return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression")
|
|
};
|
|
|
|
pp$3.parseProperty = function(isPattern, refDestructuringErrors) {
|
|
var prop = this.startNode(), isGenerator, isAsync, startPos, startLoc;
|
|
if (this.options.ecmaVersion >= 9 && this.eat(types.ellipsis)) {
|
|
if (isPattern) {
|
|
prop.argument = this.parseIdent(false);
|
|
if (this.type === types.comma) {
|
|
this.raise(this.start, "Comma is not permitted after the rest element");
|
|
}
|
|
return this.finishNode(prop, "RestElement")
|
|
}
|
|
if (this.type === types.parenL && refDestructuringErrors) {
|
|
if (refDestructuringErrors.parenthesizedAssign < 0) {
|
|
refDestructuringErrors.parenthesizedAssign = this.start;
|
|
}
|
|
if (refDestructuringErrors.parenthesizedBind < 0) {
|
|
refDestructuringErrors.parenthesizedBind = this.start;
|
|
}
|
|
}
|
|
prop.argument = this.parseMaybeAssign(false, refDestructuringErrors);
|
|
if (this.type === types.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {
|
|
refDestructuringErrors.trailingComma = this.start;
|
|
}
|
|
return this.finishNode(prop, "SpreadElement")
|
|
}
|
|
if (this.options.ecmaVersion >= 6) {
|
|
prop.method = false;
|
|
prop.shorthand = false;
|
|
if (isPattern || refDestructuringErrors) {
|
|
startPos = this.start;
|
|
startLoc = this.startLoc;
|
|
}
|
|
if (!isPattern)
|
|
{ isGenerator = this.eat(types.star); }
|
|
}
|
|
var containsEsc = this.containsEsc;
|
|
this.parsePropertyName(prop);
|
|
if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) {
|
|
isAsync = true;
|
|
isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);
|
|
this.parsePropertyName(prop, refDestructuringErrors);
|
|
} else {
|
|
isAsync = false;
|
|
}
|
|
this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc);
|
|
return this.finishNode(prop, "Property")
|
|
};
|
|
|
|
pp$3.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) {
|
|
if ((isGenerator || isAsync) && this.type === types.colon)
|
|
{ this.unexpected(); }
|
|
|
|
if (this.eat(types.colon)) {
|
|
prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors);
|
|
prop.kind = "init";
|
|
} else if (this.options.ecmaVersion >= 6 && this.type === types.parenL) {
|
|
if (isPattern) { this.unexpected(); }
|
|
prop.kind = "init";
|
|
prop.method = true;
|
|
prop.value = this.parseMethod(isGenerator, isAsync);
|
|
} else if (!isPattern && !containsEsc &&
|
|
this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
|
|
(prop.key.name === "get" || prop.key.name === "set") &&
|
|
(this.type !== types.comma && this.type !== types.braceR)) {
|
|
if (isGenerator || isAsync) { this.unexpected(); }
|
|
prop.kind = prop.key.name;
|
|
this.parsePropertyName(prop);
|
|
prop.value = this.parseMethod(false);
|
|
var paramCount = prop.kind === "get" ? 0 : 1;
|
|
if (prop.value.params.length !== paramCount) {
|
|
var start = prop.value.start;
|
|
if (prop.kind === "get")
|
|
{ this.raiseRecoverable(start, "getter should have no params"); }
|
|
else
|
|
{ this.raiseRecoverable(start, "setter should have exactly one param"); }
|
|
} else {
|
|
if (prop.kind === "set" && prop.value.params[0].type === "RestElement")
|
|
{ this.raiseRecoverable(prop.value.params[0].start, "Setter cannot use rest params"); }
|
|
}
|
|
} else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
|
|
this.checkUnreserved(prop.key);
|
|
prop.kind = "init";
|
|
if (isPattern) {
|
|
prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
|
|
} else if (this.type === types.eq && refDestructuringErrors) {
|
|
if (refDestructuringErrors.shorthandAssign < 0)
|
|
{ refDestructuringErrors.shorthandAssign = this.start; }
|
|
prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
|
|
} else {
|
|
prop.value = prop.key;
|
|
}
|
|
prop.shorthand = true;
|
|
} else { this.unexpected(); }
|
|
};
|
|
|
|
pp$3.parsePropertyName = function(prop) {
|
|
if (this.options.ecmaVersion >= 6) {
|
|
if (this.eat(types.bracketL)) {
|
|
prop.computed = true;
|
|
prop.key = this.parseMaybeAssign();
|
|
this.expect(types.bracketR);
|
|
return prop.key
|
|
} else {
|
|
prop.computed = false;
|
|
}
|
|
}
|
|
return prop.key = this.type === types.num || this.type === types.string ? this.parseExprAtom() : this.parseIdent(true)
|
|
};
|
|
|
|
|
|
pp$3.initFunction = function(node) {
|
|
node.id = null;
|
|
if (this.options.ecmaVersion >= 6) {
|
|
node.generator = false;
|
|
node.expression = false;
|
|
}
|
|
if (this.options.ecmaVersion >= 8)
|
|
{ node.async = false; }
|
|
};
|
|
|
|
|
|
pp$3.parseMethod = function(isGenerator, isAsync) {
|
|
var node = this.startNode(), oldInGen = this.inGenerator, oldInAsync = this.inAsync,
|
|
oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldInFunc = this.inFunction;
|
|
|
|
this.initFunction(node);
|
|
if (this.options.ecmaVersion >= 6)
|
|
{ node.generator = isGenerator; }
|
|
if (this.options.ecmaVersion >= 8)
|
|
{ node.async = !!isAsync; }
|
|
|
|
this.inGenerator = node.generator;
|
|
this.inAsync = node.async;
|
|
this.yieldPos = 0;
|
|
this.awaitPos = 0;
|
|
this.inFunction = true;
|
|
this.enterFunctionScope();
|
|
|
|
this.expect(types.parenL);
|
|
node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);
|
|
this.checkYieldAwaitInDefaultParams();
|
|
this.parseFunctionBody(node, false);
|
|
|
|
this.inGenerator = oldInGen;
|
|
this.inAsync = oldInAsync;
|
|
this.yieldPos = oldYieldPos;
|
|
this.awaitPos = oldAwaitPos;
|
|
this.inFunction = oldInFunc;
|
|
return this.finishNode(node, "FunctionExpression")
|
|
};
|
|
|
|
|
|
pp$3.parseArrowExpression = function(node, params, isAsync) {
|
|
var oldInGen = this.inGenerator, oldInAsync = this.inAsync,
|
|
oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldInFunc = this.inFunction;
|
|
|
|
this.enterFunctionScope();
|
|
this.initFunction(node);
|
|
if (this.options.ecmaVersion >= 8)
|
|
{ node.async = !!isAsync; }
|
|
|
|
this.inGenerator = false;
|
|
this.inAsync = node.async;
|
|
this.yieldPos = 0;
|
|
this.awaitPos = 0;
|
|
this.inFunction = true;
|
|
|
|
node.params = this.toAssignableList(params, true);
|
|
this.parseFunctionBody(node, true);
|
|
|
|
this.inGenerator = oldInGen;
|
|
this.inAsync = oldInAsync;
|
|
this.yieldPos = oldYieldPos;
|
|
this.awaitPos = oldAwaitPos;
|
|
this.inFunction = oldInFunc;
|
|
return this.finishNode(node, "ArrowFunctionExpression")
|
|
};
|
|
|
|
|
|
pp$3.parseFunctionBody = function(node, isArrowFunction) {
|
|
var isExpression = isArrowFunction && this.type !== types.braceL;
|
|
var oldStrict = this.strict, useStrict = false;
|
|
|
|
if (isExpression) {
|
|
node.body = this.parseMaybeAssign();
|
|
node.expression = true;
|
|
this.checkParams(node, false);
|
|
} else {
|
|
var nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params);
|
|
if (!oldStrict || nonSimple) {
|
|
useStrict = this.strictDirective(this.end);
|
|
if (useStrict && nonSimple)
|
|
{ this.raiseRecoverable(node.start, "Illegal 'use strict' directive in function with non-simple parameter list"); }
|
|
}
|
|
var oldLabels = this.labels;
|
|
this.labels = [];
|
|
if (useStrict) { this.strict = true; }
|
|
|
|
this.checkParams(node, !oldStrict && !useStrict && !isArrowFunction && this.isSimpleParamList(node.params));
|
|
node.body = this.parseBlock(false);
|
|
node.expression = false;
|
|
this.adaptDirectivePrologue(node.body.body);
|
|
this.labels = oldLabels;
|
|
}
|
|
this.exitFunctionScope();
|
|
|
|
if (this.strict && node.id) {
|
|
this.checkLVal(node.id, "none");
|
|
}
|
|
this.strict = oldStrict;
|
|
};
|
|
|
|
pp$3.isSimpleParamList = function(params) {
|
|
for (var i = 0, list = params; i < list.length; i += 1)
|
|
{
|
|
var param = list[i];
|
|
|
|
if (param.type !== "Identifier") { return false
|
|
} }
|
|
return true
|
|
};
|
|
|
|
|
|
pp$3.checkParams = function(node, allowDuplicates) {
|
|
var this$1 = this;
|
|
|
|
var nameHash = {};
|
|
for (var i = 0, list = node.params; i < list.length; i += 1)
|
|
{
|
|
var param = list[i];
|
|
|
|
this$1.checkLVal(param, "var", allowDuplicates ? null : nameHash);
|
|
}
|
|
};
|
|
|
|
|
|
pp$3.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {
|
|
var this$1 = this;
|
|
|
|
var elts = [], first = true;
|
|
while (!this.eat(close)) {
|
|
if (!first) {
|
|
this$1.expect(types.comma);
|
|
if (allowTrailingComma && this$1.afterTrailingComma(close)) { break }
|
|
} else { first = false; }
|
|
|
|
var elt = (void 0);
|
|
if (allowEmpty && this$1.type === types.comma)
|
|
{ elt = null; }
|
|
else if (this$1.type === types.ellipsis) {
|
|
elt = this$1.parseSpread(refDestructuringErrors);
|
|
if (refDestructuringErrors && this$1.type === types.comma && refDestructuringErrors.trailingComma < 0)
|
|
{ refDestructuringErrors.trailingComma = this$1.start; }
|
|
} else {
|
|
elt = this$1.parseMaybeAssign(false, refDestructuringErrors);
|
|
}
|
|
elts.push(elt);
|
|
}
|
|
return elts
|
|
};
|
|
|
|
pp$3.checkUnreserved = function(ref) {
|
|
var start = ref.start;
|
|
var end = ref.end;
|
|
var name = ref.name;
|
|
|
|
if (this.inGenerator && name === "yield")
|
|
{ this.raiseRecoverable(start, "Can not use 'yield' as identifier inside a generator"); }
|
|
if (this.inAsync && name === "await")
|
|
{ this.raiseRecoverable(start, "Can not use 'await' as identifier inside an async function"); }
|
|
if (this.isKeyword(name))
|
|
{ this.raise(start, ("Unexpected keyword '" + name + "'")); }
|
|
if (this.options.ecmaVersion < 6 &&
|
|
this.input.slice(start, end).indexOf("\\") !== -1) { return }
|
|
var re = this.strict ? this.reservedWordsStrict : this.reservedWords;
|
|
if (re.test(name)) {
|
|
if (!this.inAsync && name === "await")
|
|
{ this.raiseRecoverable(start, "Can not use keyword 'await' outside an async function"); }
|
|
this.raiseRecoverable(start, ("The keyword '" + name + "' is reserved"));
|
|
}
|
|
};
|
|
|
|
|
|
pp$3.parseIdent = function(liberal, isBinding) {
|
|
var node = this.startNode();
|
|
if (liberal && this.options.allowReserved === "never") { liberal = false; }
|
|
if (this.type === types.name) {
|
|
node.name = this.value;
|
|
} else if (this.type.keyword) {
|
|
node.name = this.type.keyword;
|
|
|
|
if ((node.name === "class" || node.name === "function") &&
|
|
(this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {
|
|
this.context.pop();
|
|
}
|
|
} else {
|
|
this.unexpected();
|
|
}
|
|
this.next();
|
|
this.finishNode(node, "Identifier");
|
|
if (!liberal) { this.checkUnreserved(node); }
|
|
return node
|
|
};
|
|
|
|
|
|
pp$3.parseYield = function() {
|
|
if (!this.yieldPos) { this.yieldPos = this.start; }
|
|
|
|
var node = this.startNode();
|
|
this.next();
|
|
if (this.type === types.semi || this.canInsertSemicolon() || (this.type !== types.star && !this.type.startsExpr)) {
|
|
node.delegate = false;
|
|
node.argument = null;
|
|
} else {
|
|
node.delegate = this.eat(types.star);
|
|
node.argument = this.parseMaybeAssign();
|
|
}
|
|
return this.finishNode(node, "YieldExpression")
|
|
};
|
|
|
|
pp$3.parseAwait = function() {
|
|
if (!this.awaitPos) { this.awaitPos = this.start; }
|
|
|
|
var node = this.startNode();
|
|
this.next();
|
|
node.argument = this.parseMaybeUnary(null, true);
|
|
return this.finishNode(node, "AwaitExpression")
|
|
};
|
|
|
|
var pp$4 = Parser.prototype;
|
|
|
|
|
|
pp$4.raise = function(pos, message) {
|
|
var loc = getLineInfo(this.input, pos);
|
|
message += " (" + loc.line + ":" + loc.column + ")";
|
|
var err = new SyntaxError(message);
|
|
err.pos = pos; err.loc = loc; err.raisedAt = this.pos;
|
|
throw err
|
|
};
|
|
|
|
pp$4.raiseRecoverable = pp$4.raise;
|
|
|
|
pp$4.curPosition = function() {
|
|
if (this.options.locations) {
|
|
return new Position(this.curLine, this.pos - this.lineStart)
|
|
}
|
|
};
|
|
|
|
var pp$5 = Parser.prototype;
|
|
|
|
var assign = Object.assign || function(target) {
|
|
var sources = [], len = arguments.length - 1;
|
|
while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ];
|
|
|
|
for (var i = 0, list = sources; i < list.length; i += 1) {
|
|
var source = list[i];
|
|
|
|
for (var key in source) {
|
|
if (has(source, key)) {
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
}
|
|
return target
|
|
};
|
|
|
|
|
|
pp$5.enterFunctionScope = function() {
|
|
this.scopeStack.push({var: {}, lexical: {}, childVar: {}, parentLexical: {}});
|
|
};
|
|
|
|
pp$5.exitFunctionScope = function() {
|
|
this.scopeStack.pop();
|
|
};
|
|
|
|
pp$5.enterLexicalScope = function() {
|
|
var parentScope = this.scopeStack[this.scopeStack.length - 1];
|
|
var childScope = {var: {}, lexical: {}, childVar: {}, parentLexical: {}};
|
|
|
|
this.scopeStack.push(childScope);
|
|
assign(childScope.parentLexical, parentScope.lexical, parentScope.parentLexical);
|
|
};
|
|
|
|
pp$5.exitLexicalScope = function() {
|
|
var childScope = this.scopeStack.pop();
|
|
var parentScope = this.scopeStack[this.scopeStack.length - 1];
|
|
|
|
assign(parentScope.childVar, childScope.var, childScope.childVar);
|
|
};
|
|
|
|
pp$5.canDeclareVarName = function(name) {
|
|
var currentScope = this.scopeStack[this.scopeStack.length - 1];
|
|
|
|
return !has(currentScope.lexical, name) && !has(currentScope.parentLexical, name)
|
|
};
|
|
|
|
pp$5.canDeclareLexicalName = function(name) {
|
|
var currentScope = this.scopeStack[this.scopeStack.length - 1];
|
|
|
|
return !has(currentScope.lexical, name) && !has(currentScope.var, name) && !has(currentScope.childVar, name)
|
|
};
|
|
|
|
pp$5.declareVarName = function(name) {
|
|
this.scopeStack[this.scopeStack.length - 1].var[name] = true;
|
|
};
|
|
|
|
pp$5.declareLexicalName = function(name) {
|
|
this.scopeStack[this.scopeStack.length - 1].lexical[name] = true;
|
|
};
|
|
|
|
var Node = function Node(parser, pos, loc) {
|
|
this.type = "";
|
|
this.start = pos;
|
|
this.end = 0;
|
|
if (parser.options.locations)
|
|
{ this.loc = new SourceLocation(parser, loc); }
|
|
if (parser.options.directSourceFile)
|
|
{ this.sourceFile = parser.options.directSourceFile; }
|
|
if (parser.options.ranges)
|
|
{ this.range = [pos, 0]; }
|
|
};
|
|
|
|
|
|
var pp$6 = Parser.prototype;
|
|
|
|
pp$6.startNode = function() {
|
|
return new Node(this, this.start, this.startLoc)
|
|
};
|
|
|
|
pp$6.startNodeAt = function(pos, loc) {
|
|
return new Node(this, pos, loc)
|
|
};
|
|
|
|
|
|
function finishNodeAt(node, type, pos, loc) {
|
|
node.type = type;
|
|
node.end = pos;
|
|
if (this.options.locations)
|
|
{ node.loc.end = loc; }
|
|
if (this.options.ranges)
|
|
{ node.range[1] = pos; }
|
|
return node
|
|
}
|
|
|
|
pp$6.finishNode = function(node, type) {
|
|
return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)
|
|
};
|
|
|
|
|
|
pp$6.finishNodeAt = function(node, type, pos, loc) {
|
|
return finishNodeAt.call(this, node, type, pos, loc)
|
|
};
|
|
|
|
|
|
var TokContext = function TokContext(token, isExpr, preserveSpace, override, generator) {
|
|
this.token = token;
|
|
this.isExpr = !!isExpr;
|
|
this.preserveSpace = !!preserveSpace;
|
|
this.override = override;
|
|
this.generator = !!generator;
|
|
};
|
|
|
|
var types$1 = {
|
|
b_stat: new TokContext("{", false),
|
|
b_expr: new TokContext("{", true),
|
|
b_tmpl: new TokContext("${", false),
|
|
p_stat: new TokContext("(", false),
|
|
p_expr: new TokContext("(", true),
|
|
q_tmpl: new TokContext("`", true, true, function (p) { return p.tryReadTemplateToken(); }),
|
|
f_stat: new TokContext("function", false),
|
|
f_expr: new TokContext("function", true),
|
|
f_expr_gen: new TokContext("function", true, false, null, true),
|
|
f_gen: new TokContext("function", false, false, null, true)
|
|
};
|
|
|
|
var pp$7 = Parser.prototype;
|
|
|
|
pp$7.initialContext = function() {
|
|
return [types$1.b_stat]
|
|
};
|
|
|
|
pp$7.braceIsBlock = function(prevType) {
|
|
var parent = this.curContext();
|
|
if (parent === types$1.f_expr || parent === types$1.f_stat)
|
|
{ return true }
|
|
if (prevType === types.colon && (parent === types$1.b_stat || parent === types$1.b_expr))
|
|
{ return !parent.isExpr }
|
|
|
|
if (prevType === types._return || prevType === types.name && this.exprAllowed)
|
|
{ return lineBreak.test(this.input.slice(this.lastTokEnd, this.start)) }
|
|
if (prevType === types._else || prevType === types.semi || prevType === types.eof || prevType === types.parenR || prevType === types.arrow)
|
|
{ return true }
|
|
if (prevType === types.braceL)
|
|
{ return parent === types$1.b_stat }
|
|
if (prevType === types._var || prevType === types.name)
|
|
{ return false }
|
|
return !this.exprAllowed
|
|
};
|
|
|
|
pp$7.inGeneratorContext = function() {
|
|
var this$1 = this;
|
|
|
|
for (var i = this.context.length - 1; i >= 1; i--) {
|
|
var context = this$1.context[i];
|
|
if (context.token === "function")
|
|
{ return context.generator }
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$7.updateContext = function(prevType) {
|
|
var update, type = this.type;
|
|
if (type.keyword && prevType === types.dot)
|
|
{ this.exprAllowed = false; }
|
|
else if (update = type.updateContext)
|
|
{ update.call(this, prevType); }
|
|
else
|
|
{ this.exprAllowed = type.beforeExpr; }
|
|
};
|
|
|
|
|
|
types.parenR.updateContext = types.braceR.updateContext = function() {
|
|
if (this.context.length === 1) {
|
|
this.exprAllowed = true;
|
|
return
|
|
}
|
|
var out = this.context.pop();
|
|
if (out === types$1.b_stat && this.curContext().token === "function") {
|
|
out = this.context.pop();
|
|
}
|
|
this.exprAllowed = !out.isExpr;
|
|
};
|
|
|
|
types.braceL.updateContext = function(prevType) {
|
|
this.context.push(this.braceIsBlock(prevType) ? types$1.b_stat : types$1.b_expr);
|
|
this.exprAllowed = true;
|
|
};
|
|
|
|
types.dollarBraceL.updateContext = function() {
|
|
this.context.push(types$1.b_tmpl);
|
|
this.exprAllowed = true;
|
|
};
|
|
|
|
types.parenL.updateContext = function(prevType) {
|
|
var statementParens = prevType === types._if || prevType === types._for || prevType === types._with || prevType === types._while;
|
|
this.context.push(statementParens ? types$1.p_stat : types$1.p_expr);
|
|
this.exprAllowed = true;
|
|
};
|
|
|
|
types.incDec.updateContext = function() {
|
|
};
|
|
|
|
types._function.updateContext = types._class.updateContext = function(prevType) {
|
|
if (prevType.beforeExpr && prevType !== types.semi && prevType !== types._else &&
|
|
!((prevType === types.colon || prevType === types.braceL) && this.curContext() === types$1.b_stat))
|
|
{ this.context.push(types$1.f_expr); }
|
|
else
|
|
{ this.context.push(types$1.f_stat); }
|
|
this.exprAllowed = false;
|
|
};
|
|
|
|
types.backQuote.updateContext = function() {
|
|
if (this.curContext() === types$1.q_tmpl)
|
|
{ this.context.pop(); }
|
|
else
|
|
{ this.context.push(types$1.q_tmpl); }
|
|
this.exprAllowed = false;
|
|
};
|
|
|
|
types.star.updateContext = function(prevType) {
|
|
if (prevType === types._function) {
|
|
var index = this.context.length - 1;
|
|
if (this.context[index] === types$1.f_expr)
|
|
{ this.context[index] = types$1.f_expr_gen; }
|
|
else
|
|
{ this.context[index] = types$1.f_gen; }
|
|
}
|
|
this.exprAllowed = true;
|
|
};
|
|
|
|
types.name.updateContext = function(prevType) {
|
|
var allowed = false;
|
|
if (this.options.ecmaVersion >= 6 && prevType !== types.dot) {
|
|
if (this.value === "of" && !this.exprAllowed ||
|
|
this.value === "yield" && this.inGeneratorContext())
|
|
{ allowed = true; }
|
|
}
|
|
this.exprAllowed = allowed;
|
|
};
|
|
|
|
var data = {
|
|
"$LONE": [
|
|
"ASCII",
|
|
"ASCII_Hex_Digit",
|
|
"AHex",
|
|
"Alphabetic",
|
|
"Alpha",
|
|
"Any",
|
|
"Assigned",
|
|
"Bidi_Control",
|
|
"Bidi_C",
|
|
"Bidi_Mirrored",
|
|
"Bidi_M",
|
|
"Case_Ignorable",
|
|
"CI",
|
|
"Cased",
|
|
"Changes_When_Casefolded",
|
|
"CWCF",
|
|
"Changes_When_Casemapped",
|
|
"CWCM",
|
|
"Changes_When_Lowercased",
|
|
"CWL",
|
|
"Changes_When_NFKC_Casefolded",
|
|
"CWKCF",
|
|
"Changes_When_Titlecased",
|
|
"CWT",
|
|
"Changes_When_Uppercased",
|
|
"CWU",
|
|
"Dash",
|
|
"Default_Ignorable_Code_Point",
|
|
"DI",
|
|
"Deprecated",
|
|
"Dep",
|
|
"Diacritic",
|
|
"Dia",
|
|
"Emoji",
|
|
"Emoji_Component",
|
|
"Emoji_Modifier",
|
|
"Emoji_Modifier_Base",
|
|
"Emoji_Presentation",
|
|
"Extender",
|
|
"Ext",
|
|
"Grapheme_Base",
|
|
"Gr_Base",
|
|
"Grapheme_Extend",
|
|
"Gr_Ext",
|
|
"Hex_Digit",
|
|
"Hex",
|
|
"IDS_Binary_Operator",
|
|
"IDSB",
|
|
"IDS_Trinary_Operator",
|
|
"IDST",
|
|
"ID_Continue",
|
|
"IDC",
|
|
"ID_Start",
|
|
"IDS",
|
|
"Ideographic",
|
|
"Ideo",
|
|
"Join_Control",
|
|
"Join_C",
|
|
"Logical_Order_Exception",
|
|
"LOE",
|
|
"Lowercase",
|
|
"Lower",
|
|
"Math",
|
|
"Noncharacter_Code_Point",
|
|
"NChar",
|
|
"Pattern_Syntax",
|
|
"Pat_Syn",
|
|
"Pattern_White_Space",
|
|
"Pat_WS",
|
|
"Quotation_Mark",
|
|
"QMark",
|
|
"Radical",
|
|
"Regional_Indicator",
|
|
"RI",
|
|
"Sentence_Terminal",
|
|
"STerm",
|
|
"Soft_Dotted",
|
|
"SD",
|
|
"Terminal_Punctuation",
|
|
"Term",
|
|
"Unified_Ideograph",
|
|
"UIdeo",
|
|
"Uppercase",
|
|
"Upper",
|
|
"Variation_Selector",
|
|
"VS",
|
|
"White_Space",
|
|
"space",
|
|
"XID_Continue",
|
|
"XIDC",
|
|
"XID_Start",
|
|
"XIDS"
|
|
],
|
|
"General_Category": [
|
|
"Cased_Letter",
|
|
"LC",
|
|
"Close_Punctuation",
|
|
"Pe",
|
|
"Connector_Punctuation",
|
|
"Pc",
|
|
"Control",
|
|
"Cc",
|
|
"cntrl",
|
|
"Currency_Symbol",
|
|
"Sc",
|
|
"Dash_Punctuation",
|
|
"Pd",
|
|
"Decimal_Number",
|
|
"Nd",
|
|
"digit",
|
|
"Enclosing_Mark",
|
|
"Me",
|
|
"Final_Punctuation",
|
|
"Pf",
|
|
"Format",
|
|
"Cf",
|
|
"Initial_Punctuation",
|
|
"Pi",
|
|
"Letter",
|
|
"L",
|
|
"Letter_Number",
|
|
"Nl",
|
|
"Line_Separator",
|
|
"Zl",
|
|
"Lowercase_Letter",
|
|
"Ll",
|
|
"Mark",
|
|
"M",
|
|
"Combining_Mark",
|
|
"Math_Symbol",
|
|
"Sm",
|
|
"Modifier_Letter",
|
|
"Lm",
|
|
"Modifier_Symbol",
|
|
"Sk",
|
|
"Nonspacing_Mark",
|
|
"Mn",
|
|
"Number",
|
|
"N",
|
|
"Open_Punctuation",
|
|
"Ps",
|
|
"Other",
|
|
"C",
|
|
"Other_Letter",
|
|
"Lo",
|
|
"Other_Number",
|
|
"No",
|
|
"Other_Punctuation",
|
|
"Po",
|
|
"Other_Symbol",
|
|
"So",
|
|
"Paragraph_Separator",
|
|
"Zp",
|
|
"Private_Use",
|
|
"Co",
|
|
"Punctuation",
|
|
"P",
|
|
"punct",
|
|
"Separator",
|
|
"Z",
|
|
"Space_Separator",
|
|
"Zs",
|
|
"Spacing_Mark",
|
|
"Mc",
|
|
"Surrogate",
|
|
"Cs",
|
|
"Symbol",
|
|
"S",
|
|
"Titlecase_Letter",
|
|
"Lt",
|
|
"Unassigned",
|
|
"Cn",
|
|
"Uppercase_Letter",
|
|
"Lu"
|
|
],
|
|
"Script": [
|
|
"Adlam",
|
|
"Adlm",
|
|
"Ahom",
|
|
"Anatolian_Hieroglyphs",
|
|
"Hluw",
|
|
"Arabic",
|
|
"Arab",
|
|
"Armenian",
|
|
"Armn",
|
|
"Avestan",
|
|
"Avst",
|
|
"Balinese",
|
|
"Bali",
|
|
"Bamum",
|
|
"Bamu",
|
|
"Bassa_Vah",
|
|
"Bass",
|
|
"Batak",
|
|
"Batk",
|
|
"Bengali",
|
|
"Beng",
|
|
"Bhaiksuki",
|
|
"Bhks",
|
|
"Bopomofo",
|
|
"Bopo",
|
|
"Brahmi",
|
|
"Brah",
|
|
"Braille",
|
|
"Brai",
|
|
"Buginese",
|
|
"Bugi",
|
|
"Buhid",
|
|
"Buhd",
|
|
"Canadian_Aboriginal",
|
|
"Cans",
|
|
"Carian",
|
|
"Cari",
|
|
"Caucasian_Albanian",
|
|
"Aghb",
|
|
"Chakma",
|
|
"Cakm",
|
|
"Cham",
|
|
"Cherokee",
|
|
"Cher",
|
|
"Common",
|
|
"Zyyy",
|
|
"Coptic",
|
|
"Copt",
|
|
"Qaac",
|
|
"Cuneiform",
|
|
"Xsux",
|
|
"Cypriot",
|
|
"Cprt",
|
|
"Cyrillic",
|
|
"Cyrl",
|
|
"Deseret",
|
|
"Dsrt",
|
|
"Devanagari",
|
|
"Deva",
|
|
"Duployan",
|
|
"Dupl",
|
|
"Egyptian_Hieroglyphs",
|
|
"Egyp",
|
|
"Elbasan",
|
|
"Elba",
|
|
"Ethiopic",
|
|
"Ethi",
|
|
"Georgian",
|
|
"Geor",
|
|
"Glagolitic",
|
|
"Glag",
|
|
"Gothic",
|
|
"Goth",
|
|
"Grantha",
|
|
"Gran",
|
|
"Greek",
|
|
"Grek",
|
|
"Gujarati",
|
|
"Gujr",
|
|
"Gurmukhi",
|
|
"Guru",
|
|
"Han",
|
|
"Hani",
|
|
"Hangul",
|
|
"Hang",
|
|
"Hanunoo",
|
|
"Hano",
|
|
"Hatran",
|
|
"Hatr",
|
|
"Hebrew",
|
|
"Hebr",
|
|
"Hiragana",
|
|
"Hira",
|
|
"Imperial_Aramaic",
|
|
"Armi",
|
|
"Inherited",
|
|
"Zinh",
|
|
"Qaai",
|
|
"Inscriptional_Pahlavi",
|
|
"Phli",
|
|
"Inscriptional_Parthian",
|
|
"Prti",
|
|
"Javanese",
|
|
"Java",
|
|
"Kaithi",
|
|
"Kthi",
|
|
"Kannada",
|
|
"Knda",
|
|
"Katakana",
|
|
"Kana",
|
|
"Kayah_Li",
|
|
"Kali",
|
|
"Kharoshthi",
|
|
"Khar",
|
|
"Khmer",
|
|
"Khmr",
|
|
"Khojki",
|
|
"Khoj",
|
|
"Khudawadi",
|
|
"Sind",
|
|
"Lao",
|
|
"Laoo",
|
|
"Latin",
|
|
"Latn",
|
|
"Lepcha",
|
|
"Lepc",
|
|
"Limbu",
|
|
"Limb",
|
|
"Linear_A",
|
|
"Lina",
|
|
"Linear_B",
|
|
"Linb",
|
|
"Lisu",
|
|
"Lycian",
|
|
"Lyci",
|
|
"Lydian",
|
|
"Lydi",
|
|
"Mahajani",
|
|
"Mahj",
|
|
"Malayalam",
|
|
"Mlym",
|
|
"Mandaic",
|
|
"Mand",
|
|
"Manichaean",
|
|
"Mani",
|
|
"Marchen",
|
|
"Marc",
|
|
"Masaram_Gondi",
|
|
"Gonm",
|
|
"Meetei_Mayek",
|
|
"Mtei",
|
|
"Mende_Kikakui",
|
|
"Mend",
|
|
"Meroitic_Cursive",
|
|
"Merc",
|
|
"Meroitic_Hieroglyphs",
|
|
"Mero",
|
|
"Miao",
|
|
"Plrd",
|
|
"Modi",
|
|
"Mongolian",
|
|
"Mong",
|
|
"Mro",
|
|
"Mroo",
|
|
"Multani",
|
|
"Mult",
|
|
"Myanmar",
|
|
"Mymr",
|
|
"Nabataean",
|
|
"Nbat",
|
|
"New_Tai_Lue",
|
|
"Talu",
|
|
"Newa",
|
|
"Nko",
|
|
"Nkoo",
|
|
"Nushu",
|
|
"Nshu",
|
|
"Ogham",
|
|
"Ogam",
|
|
"Ol_Chiki",
|
|
"Olck",
|
|
"Old_Hungarian",
|
|
"Hung",
|
|
"Old_Italic",
|
|
"Ital",
|
|
"Old_North_Arabian",
|
|
"Narb",
|
|
"Old_Permic",
|
|
"Perm",
|
|
"Old_Persian",
|
|
"Xpeo",
|
|
"Old_South_Arabian",
|
|
"Sarb",
|
|
"Old_Turkic",
|
|
"Orkh",
|
|
"Oriya",
|
|
"Orya",
|
|
"Osage",
|
|
"Osge",
|
|
"Osmanya",
|
|
"Osma",
|
|
"Pahawh_Hmong",
|
|
"Hmng",
|
|
"Palmyrene",
|
|
"Palm",
|
|
"Pau_Cin_Hau",
|
|
"Pauc",
|
|
"Phags_Pa",
|
|
"Phag",
|
|
"Phoenician",
|
|
"Phnx",
|
|
"Psalter_Pahlavi",
|
|
"Phlp",
|
|
"Rejang",
|
|
"Rjng",
|
|
"Runic",
|
|
"Runr",
|
|
"Samaritan",
|
|
"Samr",
|
|
"Saurashtra",
|
|
"Saur",
|
|
"Sharada",
|
|
"Shrd",
|
|
"Shavian",
|
|
"Shaw",
|
|
"Siddham",
|
|
"Sidd",
|
|
"SignWriting",
|
|
"Sgnw",
|
|
"Sinhala",
|
|
"Sinh",
|
|
"Sora_Sompeng",
|
|
"Sora",
|
|
"Soyombo",
|
|
"Soyo",
|
|
"Sundanese",
|
|
"Sund",
|
|
"Syloti_Nagri",
|
|
"Sylo",
|
|
"Syriac",
|
|
"Syrc",
|
|
"Tagalog",
|
|
"Tglg",
|
|
"Tagbanwa",
|
|
"Tagb",
|
|
"Tai_Le",
|
|
"Tale",
|
|
"Tai_Tham",
|
|
"Lana",
|
|
"Tai_Viet",
|
|
"Tavt",
|
|
"Takri",
|
|
"Takr",
|
|
"Tamil",
|
|
"Taml",
|
|
"Tangut",
|
|
"Tang",
|
|
"Telugu",
|
|
"Telu",
|
|
"Thaana",
|
|
"Thaa",
|
|
"Thai",
|
|
"Tibetan",
|
|
"Tibt",
|
|
"Tifinagh",
|
|
"Tfng",
|
|
"Tirhuta",
|
|
"Tirh",
|
|
"Ugaritic",
|
|
"Ugar",
|
|
"Vai",
|
|
"Vaii",
|
|
"Warang_Citi",
|
|
"Wara",
|
|
"Yi",
|
|
"Yiii",
|
|
"Zanabazar_Square",
|
|
"Zanb"
|
|
]
|
|
};
|
|
Array.prototype.push.apply(data.$LONE, data.General_Category);
|
|
data.gc = data.General_Category;
|
|
data.sc = data.Script_Extensions = data.scx = data.Script;
|
|
|
|
var pp$9 = Parser.prototype;
|
|
|
|
var RegExpValidationState = function RegExpValidationState(parser) {
|
|
this.parser = parser;
|
|
this.validFlags = "gim" + (parser.options.ecmaVersion >= 6 ? "uy" : "") + (parser.options.ecmaVersion >= 9 ? "s" : "");
|
|
this.source = "";
|
|
this.flags = "";
|
|
this.start = 0;
|
|
this.switchU = false;
|
|
this.switchN = false;
|
|
this.pos = 0;
|
|
this.lastIntValue = 0;
|
|
this.lastStringValue = "";
|
|
this.lastAssertionIsQuantifiable = false;
|
|
this.numCapturingParens = 0;
|
|
this.maxBackReference = 0;
|
|
this.groupNames = [];
|
|
this.backReferenceNames = [];
|
|
};
|
|
|
|
RegExpValidationState.prototype.reset = function reset (start, pattern, flags) {
|
|
var unicode = flags.indexOf("u") !== -1;
|
|
this.start = start | 0;
|
|
this.source = pattern + "";
|
|
this.flags = flags;
|
|
this.switchU = unicode && this.parser.options.ecmaVersion >= 6;
|
|
this.switchN = unicode && this.parser.options.ecmaVersion >= 9;
|
|
};
|
|
|
|
RegExpValidationState.prototype.raise = function raise (message) {
|
|
this.parser.raiseRecoverable(this.start, ("Invalid regular expression: /" + (this.source) + "/: " + message));
|
|
};
|
|
|
|
RegExpValidationState.prototype.at = function at (i) {
|
|
var s = this.source;
|
|
var l = s.length;
|
|
if (i >= l) {
|
|
return -1
|
|
}
|
|
var c = s.charCodeAt(i);
|
|
if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {
|
|
return c
|
|
}
|
|
return (c << 10) + s.charCodeAt(i + 1) - 0x35FDC00
|
|
};
|
|
|
|
RegExpValidationState.prototype.nextIndex = function nextIndex (i) {
|
|
var s = this.source;
|
|
var l = s.length;
|
|
if (i >= l) {
|
|
return l
|
|
}
|
|
var c = s.charCodeAt(i);
|
|
if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {
|
|
return i + 1
|
|
}
|
|
return i + 2
|
|
};
|
|
|
|
RegExpValidationState.prototype.current = function current () {
|
|
return this.at(this.pos)
|
|
};
|
|
|
|
RegExpValidationState.prototype.lookahead = function lookahead () {
|
|
return this.at(this.nextIndex(this.pos))
|
|
};
|
|
|
|
RegExpValidationState.prototype.advance = function advance () {
|
|
this.pos = this.nextIndex(this.pos);
|
|
};
|
|
|
|
RegExpValidationState.prototype.eat = function eat (ch) {
|
|
if (this.current() === ch) {
|
|
this.advance();
|
|
return true
|
|
}
|
|
return false
|
|
};
|
|
|
|
function codePointToString$1(ch) {
|
|
if (ch <= 0xFFFF) { return String.fromCharCode(ch) }
|
|
ch -= 0x10000;
|
|
return String.fromCharCode((ch >> 10) + 0xD800, (ch & 0x03FF) + 0xDC00)
|
|
}
|
|
|
|
pp$9.validateRegExpFlags = function(state) {
|
|
var this$1 = this;
|
|
|
|
var validFlags = state.validFlags;
|
|
var flags = state.flags;
|
|
|
|
for (var i = 0; i < flags.length; i++) {
|
|
var flag = flags.charAt(i);
|
|
if (validFlags.indexOf(flag) === -1) {
|
|
this$1.raise(state.start, "Invalid regular expression flag");
|
|
}
|
|
if (flags.indexOf(flag, i + 1) > -1) {
|
|
this$1.raise(state.start, "Duplicate regular expression flag");
|
|
}
|
|
}
|
|
};
|
|
|
|
pp$9.validateRegExpPattern = function(state) {
|
|
this.regexp_pattern(state);
|
|
|
|
if (!state.switchN && this.options.ecmaVersion >= 9 && state.groupNames.length > 0) {
|
|
state.switchN = true;
|
|
this.regexp_pattern(state);
|
|
}
|
|
};
|
|
|
|
pp$9.regexp_pattern = function(state) {
|
|
state.pos = 0;
|
|
state.lastIntValue = 0;
|
|
state.lastStringValue = "";
|
|
state.lastAssertionIsQuantifiable = false;
|
|
state.numCapturingParens = 0;
|
|
state.maxBackReference = 0;
|
|
state.groupNames.length = 0;
|
|
state.backReferenceNames.length = 0;
|
|
|
|
this.regexp_disjunction(state);
|
|
|
|
if (state.pos !== state.source.length) {
|
|
if (state.eat(0x29 )) {
|
|
state.raise("Unmatched ')'");
|
|
}
|
|
if (state.eat(0x5D ) || state.eat(0x7D )) {
|
|
state.raise("Lone quantifier brackets");
|
|
}
|
|
}
|
|
if (state.maxBackReference > state.numCapturingParens) {
|
|
state.raise("Invalid escape");
|
|
}
|
|
for (var i = 0, list = state.backReferenceNames; i < list.length; i += 1) {
|
|
var name = list[i];
|
|
|
|
if (state.groupNames.indexOf(name) === -1) {
|
|
state.raise("Invalid named capture referenced");
|
|
}
|
|
}
|
|
};
|
|
|
|
pp$9.regexp_disjunction = function(state) {
|
|
var this$1 = this;
|
|
|
|
this.regexp_alternative(state);
|
|
while (state.eat(0x7C )) {
|
|
this$1.regexp_alternative(state);
|
|
}
|
|
|
|
if (this.regexp_eatQuantifier(state, true)) {
|
|
state.raise("Nothing to repeat");
|
|
}
|
|
if (state.eat(0x7B )) {
|
|
state.raise("Lone quantifier brackets");
|
|
}
|
|
};
|
|
|
|
pp$9.regexp_alternative = function(state) {
|
|
while (state.pos < state.source.length && this.regexp_eatTerm(state))
|
|
{ }
|
|
};
|
|
|
|
pp$9.regexp_eatTerm = function(state) {
|
|
if (this.regexp_eatAssertion(state)) {
|
|
if (state.lastAssertionIsQuantifiable && this.regexp_eatQuantifier(state)) {
|
|
if (state.switchU) {
|
|
state.raise("Invalid quantifier");
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
if (state.switchU ? this.regexp_eatAtom(state) : this.regexp_eatExtendedAtom(state)) {
|
|
this.regexp_eatQuantifier(state);
|
|
return true
|
|
}
|
|
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatAssertion = function(state) {
|
|
var start = state.pos;
|
|
state.lastAssertionIsQuantifiable = false;
|
|
|
|
if (state.eat(0x5E ) || state.eat(0x24 )) {
|
|
return true
|
|
}
|
|
|
|
if (state.eat(0x5C )) {
|
|
if (state.eat(0x42 ) || state.eat(0x62 )) {
|
|
return true
|
|
}
|
|
state.pos = start;
|
|
}
|
|
|
|
if (state.eat(0x28 ) && state.eat(0x3F )) {
|
|
var lookbehind = false;
|
|
if (this.options.ecmaVersion >= 9) {
|
|
lookbehind = state.eat(0x3C );
|
|
}
|
|
if (state.eat(0x3D ) || state.eat(0x21 )) {
|
|
this.regexp_disjunction(state);
|
|
if (!state.eat(0x29 )) {
|
|
state.raise("Unterminated group");
|
|
}
|
|
state.lastAssertionIsQuantifiable = !lookbehind;
|
|
return true
|
|
}
|
|
}
|
|
|
|
state.pos = start;
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatQuantifier = function(state, noError) {
|
|
if ( noError === void 0 ) noError = false;
|
|
|
|
if (this.regexp_eatQuantifierPrefix(state, noError)) {
|
|
state.eat(0x3F );
|
|
return true
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatQuantifierPrefix = function(state, noError) {
|
|
return (
|
|
state.eat(0x2A ) ||
|
|
state.eat(0x2B ) ||
|
|
state.eat(0x3F ) ||
|
|
this.regexp_eatBracedQuantifier(state, noError)
|
|
)
|
|
};
|
|
pp$9.regexp_eatBracedQuantifier = function(state, noError) {
|
|
var start = state.pos;
|
|
if (state.eat(0x7B )) {
|
|
var min = 0, max = -1;
|
|
if (this.regexp_eatDecimalDigits(state)) {
|
|
min = state.lastIntValue;
|
|
if (state.eat(0x2C ) && this.regexp_eatDecimalDigits(state)) {
|
|
max = state.lastIntValue;
|
|
}
|
|
if (state.eat(0x7D )) {
|
|
if (max !== -1 && max < min && !noError) {
|
|
state.raise("numbers out of order in {} quantifier");
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
if (state.switchU && !noError) {
|
|
state.raise("Incomplete quantifier");
|
|
}
|
|
state.pos = start;
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatAtom = function(state) {
|
|
return (
|
|
this.regexp_eatPatternCharacters(state) ||
|
|
state.eat(0x2E ) ||
|
|
this.regexp_eatReverseSolidusAtomEscape(state) ||
|
|
this.regexp_eatCharacterClass(state) ||
|
|
this.regexp_eatUncapturingGroup(state) ||
|
|
this.regexp_eatCapturingGroup(state)
|
|
)
|
|
};
|
|
pp$9.regexp_eatReverseSolidusAtomEscape = function(state) {
|
|
var start = state.pos;
|
|
if (state.eat(0x5C )) {
|
|
if (this.regexp_eatAtomEscape(state)) {
|
|
return true
|
|
}
|
|
state.pos = start;
|
|
}
|
|
return false
|
|
};
|
|
pp$9.regexp_eatUncapturingGroup = function(state) {
|
|
var start = state.pos;
|
|
if (state.eat(0x28 )) {
|
|
if (state.eat(0x3F ) && state.eat(0x3A )) {
|
|
this.regexp_disjunction(state);
|
|
if (state.eat(0x29 )) {
|
|
return true
|
|
}
|
|
state.raise("Unterminated group");
|
|
}
|
|
state.pos = start;
|
|
}
|
|
return false
|
|
};
|
|
pp$9.regexp_eatCapturingGroup = function(state) {
|
|
if (state.eat(0x28 )) {
|
|
if (this.options.ecmaVersion >= 9) {
|
|
this.regexp_groupSpecifier(state);
|
|
} else if (state.current() === 0x3F ) {
|
|
state.raise("Invalid group");
|
|
}
|
|
this.regexp_disjunction(state);
|
|
if (state.eat(0x29 )) {
|
|
state.numCapturingParens += 1;
|
|
return true
|
|
}
|
|
state.raise("Unterminated group");
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatExtendedAtom = function(state) {
|
|
return (
|
|
state.eat(0x2E ) ||
|
|
this.regexp_eatReverseSolidusAtomEscape(state) ||
|
|
this.regexp_eatCharacterClass(state) ||
|
|
this.regexp_eatUncapturingGroup(state) ||
|
|
this.regexp_eatCapturingGroup(state) ||
|
|
this.regexp_eatInvalidBracedQuantifier(state) ||
|
|
this.regexp_eatExtendedPatternCharacter(state)
|
|
)
|
|
};
|
|
|
|
pp$9.regexp_eatInvalidBracedQuantifier = function(state) {
|
|
if (this.regexp_eatBracedQuantifier(state, true)) {
|
|
state.raise("Nothing to repeat");
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatSyntaxCharacter = function(state) {
|
|
var ch = state.current();
|
|
if (isSyntaxCharacter(ch)) {
|
|
state.lastIntValue = ch;
|
|
state.advance();
|
|
return true
|
|
}
|
|
return false
|
|
};
|
|
function isSyntaxCharacter(ch) {
|
|
return (
|
|
ch === 0x24 ||
|
|
ch >= 0x28 && ch <= 0x2B ||
|
|
ch === 0x2E ||
|
|
ch === 0x3F ||
|
|
ch >= 0x5B && ch <= 0x5E ||
|
|
ch >= 0x7B && ch <= 0x7D
|
|
)
|
|
}
|
|
|
|
pp$9.regexp_eatPatternCharacters = function(state) {
|
|
var start = state.pos;
|
|
var ch = 0;
|
|
while ((ch = state.current()) !== -1 && !isSyntaxCharacter(ch)) {
|
|
state.advance();
|
|
}
|
|
return state.pos !== start
|
|
};
|
|
|
|
pp$9.regexp_eatExtendedPatternCharacter = function(state) {
|
|
var ch = state.current();
|
|
if (
|
|
ch !== -1 &&
|
|
ch !== 0x24 &&
|
|
!(ch >= 0x28 && ch <= 0x2B ) &&
|
|
ch !== 0x2E &&
|
|
ch !== 0x3F &&
|
|
ch !== 0x5B &&
|
|
ch !== 0x5E &&
|
|
ch !== 0x7C
|
|
) {
|
|
state.advance();
|
|
return true
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_groupSpecifier = function(state) {
|
|
if (state.eat(0x3F )) {
|
|
if (this.regexp_eatGroupName(state)) {
|
|
if (state.groupNames.indexOf(state.lastStringValue) !== -1) {
|
|
state.raise("Duplicate capture group name");
|
|
}
|
|
state.groupNames.push(state.lastStringValue);
|
|
return
|
|
}
|
|
state.raise("Invalid group");
|
|
}
|
|
};
|
|
|
|
pp$9.regexp_eatGroupName = function(state) {
|
|
state.lastStringValue = "";
|
|
if (state.eat(0x3C )) {
|
|
if (this.regexp_eatRegExpIdentifierName(state) && state.eat(0x3E )) {
|
|
return true
|
|
}
|
|
state.raise("Invalid capture group name");
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatRegExpIdentifierName = function(state) {
|
|
state.lastStringValue = "";
|
|
if (this.regexp_eatRegExpIdentifierStart(state)) {
|
|
state.lastStringValue += codePointToString$1(state.lastIntValue);
|
|
while (this.regexp_eatRegExpIdentifierPart(state)) {
|
|
state.lastStringValue += codePointToString$1(state.lastIntValue);
|
|
}
|
|
return true
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatRegExpIdentifierStart = function(state) {
|
|
var start = state.pos;
|
|
var ch = state.current();
|
|
state.advance();
|
|
|
|
if (ch === 0x5C && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {
|
|
ch = state.lastIntValue;
|
|
}
|
|
if (isRegExpIdentifierStart(ch)) {
|
|
state.lastIntValue = ch;
|
|
return true
|
|
}
|
|
|
|
state.pos = start;
|
|
return false
|
|
};
|
|
function isRegExpIdentifierStart(ch) {
|
|
return isIdentifierStart(ch, true) || ch === 0x24 || ch === 0x5F
|
|
}
|
|
|
|
pp$9.regexp_eatRegExpIdentifierPart = function(state) {
|
|
var start = state.pos;
|
|
var ch = state.current();
|
|
state.advance();
|
|
|
|
if (ch === 0x5C && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {
|
|
ch = state.lastIntValue;
|
|
}
|
|
if (isRegExpIdentifierPart(ch)) {
|
|
state.lastIntValue = ch;
|
|
return true
|
|
}
|
|
|
|
state.pos = start;
|
|
return false
|
|
};
|
|
function isRegExpIdentifierPart(ch) {
|
|
return isIdentifierChar(ch, true) || ch === 0x24 || ch === 0x5F || ch === 0x200C || ch === 0x200D
|
|
}
|
|
|
|
pp$9.regexp_eatAtomEscape = function(state) {
|
|
if (
|
|
this.regexp_eatBackReference(state) ||
|
|
this.regexp_eatCharacterClassEscape(state) ||
|
|
this.regexp_eatCharacterEscape(state) ||
|
|
(state.switchN && this.regexp_eatKGroupName(state))
|
|
) {
|
|
return true
|
|
}
|
|
if (state.switchU) {
|
|
if (state.current() === 0x63 ) {
|
|
state.raise("Invalid unicode escape");
|
|
}
|
|
state.raise("Invalid escape");
|
|
}
|
|
return false
|
|
};
|
|
pp$9.regexp_eatBackReference = function(state) {
|
|
var start = state.pos;
|
|
if (this.regexp_eatDecimalEscape(state)) {
|
|
var n = state.lastIntValue;
|
|
if (state.switchU) {
|
|
if (n > state.maxBackReference) {
|
|
state.maxBackReference = n;
|
|
}
|
|
return true
|
|
}
|
|
if (n <= state.numCapturingParens) {
|
|
return true
|
|
}
|
|
state.pos = start;
|
|
}
|
|
return false
|
|
};
|
|
pp$9.regexp_eatKGroupName = function(state) {
|
|
if (state.eat(0x6B )) {
|
|
if (this.regexp_eatGroupName(state)) {
|
|
state.backReferenceNames.push(state.lastStringValue);
|
|
return true
|
|
}
|
|
state.raise("Invalid named reference");
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatCharacterEscape = function(state) {
|
|
return (
|
|
this.regexp_eatControlEscape(state) ||
|
|
this.regexp_eatCControlLetter(state) ||
|
|
this.regexp_eatZero(state) ||
|
|
this.regexp_eatHexEscapeSequence(state) ||
|
|
this.regexp_eatRegExpUnicodeEscapeSequence(state) ||
|
|
(!state.switchU && this.regexp_eatLegacyOctalEscapeSequence(state)) ||
|
|
this.regexp_eatIdentityEscape(state)
|
|
)
|
|
};
|
|
pp$9.regexp_eatCControlLetter = function(state) {
|
|
var start = state.pos;
|
|
if (state.eat(0x63 )) {
|
|
if (this.regexp_eatControlLetter(state)) {
|
|
return true
|
|
}
|
|
state.pos = start;
|
|
}
|
|
return false
|
|
};
|
|
pp$9.regexp_eatZero = function(state) {
|
|
if (state.current() === 0x30 && !isDecimalDigit(state.lookahead())) {
|
|
state.lastIntValue = 0;
|
|
state.advance();
|
|
return true
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatControlEscape = function(state) {
|
|
var ch = state.current();
|
|
if (ch === 0x74 ) {
|
|
state.lastIntValue = 0x09;
|
|
state.advance();
|
|
return true
|
|
}
|
|
if (ch === 0x6E ) {
|
|
state.lastIntValue = 0x0A;
|
|
state.advance();
|
|
return true
|
|
}
|
|
if (ch === 0x76 ) {
|
|
state.lastIntValue = 0x0B;
|
|
state.advance();
|
|
return true
|
|
}
|
|
if (ch === 0x66 ) {
|
|
state.lastIntValue = 0x0C;
|
|
state.advance();
|
|
return true
|
|
}
|
|
if (ch === 0x72 ) {
|
|
state.lastIntValue = 0x0D;
|
|
state.advance();
|
|
return true
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatControlLetter = function(state) {
|
|
var ch = state.current();
|
|
if (isControlLetter(ch)) {
|
|
state.lastIntValue = ch % 0x20;
|
|
state.advance();
|
|
return true
|
|
}
|
|
return false
|
|
};
|
|
function isControlLetter(ch) {
|
|
return (
|
|
(ch >= 0x41 && ch <= 0x5A ) ||
|
|
(ch >= 0x61 && ch <= 0x7A )
|
|
)
|
|
}
|
|
|
|
pp$9.regexp_eatRegExpUnicodeEscapeSequence = function(state) {
|
|
var start = state.pos;
|
|
|
|
if (state.eat(0x75 )) {
|
|
if (this.regexp_eatFixedHexDigits(state, 4)) {
|
|
var lead = state.lastIntValue;
|
|
if (state.switchU && lead >= 0xD800 && lead <= 0xDBFF) {
|
|
var leadSurrogateEnd = state.pos;
|
|
if (state.eat(0x5C ) && state.eat(0x75 ) && this.regexp_eatFixedHexDigits(state, 4)) {
|
|
var trail = state.lastIntValue;
|
|
if (trail >= 0xDC00 && trail <= 0xDFFF) {
|
|
state.lastIntValue = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;
|
|
return true
|
|
}
|
|
}
|
|
state.pos = leadSurrogateEnd;
|
|
state.lastIntValue = lead;
|
|
}
|
|
return true
|
|
}
|
|
if (
|
|
state.switchU &&
|
|
state.eat(0x7B ) &&
|
|
this.regexp_eatHexDigits(state) &&
|
|
state.eat(0x7D ) &&
|
|
isValidUnicode(state.lastIntValue)
|
|
) {
|
|
return true
|
|
}
|
|
if (state.switchU) {
|
|
state.raise("Invalid unicode escape");
|
|
}
|
|
state.pos = start;
|
|
}
|
|
|
|
return false
|
|
};
|
|
function isValidUnicode(ch) {
|
|
return ch >= 0 && ch <= 0x10FFFF
|
|
}
|
|
|
|
pp$9.regexp_eatIdentityEscape = function(state) {
|
|
if (state.switchU) {
|
|
if (this.regexp_eatSyntaxCharacter(state)) {
|
|
return true
|
|
}
|
|
if (state.eat(0x2F )) {
|
|
state.lastIntValue = 0x2F;
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
var ch = state.current();
|
|
if (ch !== 0x63 && (!state.switchN || ch !== 0x6B )) {
|
|
state.lastIntValue = ch;
|
|
state.advance();
|
|
return true
|
|
}
|
|
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatDecimalEscape = function(state) {
|
|
state.lastIntValue = 0;
|
|
var ch = state.current();
|
|
if (ch >= 0x31 && ch <= 0x39 ) {
|
|
do {
|
|
state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 );
|
|
state.advance();
|
|
} while ((ch = state.current()) >= 0x30 && ch <= 0x39 )
|
|
return true
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatCharacterClassEscape = function(state) {
|
|
var ch = state.current();
|
|
|
|
if (isCharacterClassEscape(ch)) {
|
|
state.lastIntValue = -1;
|
|
state.advance();
|
|
return true
|
|
}
|
|
|
|
if (
|
|
state.switchU &&
|
|
this.options.ecmaVersion >= 9 &&
|
|
(ch === 0x50 || ch === 0x70 )
|
|
) {
|
|
state.lastIntValue = -1;
|
|
state.advance();
|
|
if (
|
|
state.eat(0x7B ) &&
|
|
this.regexp_eatUnicodePropertyValueExpression(state) &&
|
|
state.eat(0x7D )
|
|
) {
|
|
return true
|
|
}
|
|
state.raise("Invalid property name");
|
|
}
|
|
|
|
return false
|
|
};
|
|
function isCharacterClassEscape(ch) {
|
|
return (
|
|
ch === 0x64 ||
|
|
ch === 0x44 ||
|
|
ch === 0x73 ||
|
|
ch === 0x53 ||
|
|
ch === 0x77 ||
|
|
ch === 0x57
|
|
)
|
|
}
|
|
|
|
pp$9.regexp_eatUnicodePropertyValueExpression = function(state) {
|
|
var start = state.pos;
|
|
|
|
if (this.regexp_eatUnicodePropertyName(state) && state.eat(0x3D )) {
|
|
var name = state.lastStringValue;
|
|
if (this.regexp_eatUnicodePropertyValue(state)) {
|
|
var value = state.lastStringValue;
|
|
this.regexp_validateUnicodePropertyNameAndValue(state, name, value);
|
|
return true
|
|
}
|
|
}
|
|
state.pos = start;
|
|
|
|
if (this.regexp_eatLoneUnicodePropertyNameOrValue(state)) {
|
|
var nameOrValue = state.lastStringValue;
|
|
this.regexp_validateUnicodePropertyNameOrValue(state, nameOrValue);
|
|
return true
|
|
}
|
|
return false
|
|
};
|
|
pp$9.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) {
|
|
if (!data.hasOwnProperty(name) || data[name].indexOf(value) === -1) {
|
|
state.raise("Invalid property name");
|
|
}
|
|
};
|
|
pp$9.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {
|
|
if (data.$LONE.indexOf(nameOrValue) === -1) {
|
|
state.raise("Invalid property name");
|
|
}
|
|
};
|
|
|
|
pp$9.regexp_eatUnicodePropertyName = function(state) {
|
|
var ch = 0;
|
|
state.lastStringValue = "";
|
|
while (isUnicodePropertyNameCharacter(ch = state.current())) {
|
|
state.lastStringValue += codePointToString$1(ch);
|
|
state.advance();
|
|
}
|
|
return state.lastStringValue !== ""
|
|
};
|
|
function isUnicodePropertyNameCharacter(ch) {
|
|
return isControlLetter(ch) || ch === 0x5F
|
|
}
|
|
|
|
pp$9.regexp_eatUnicodePropertyValue = function(state) {
|
|
var ch = 0;
|
|
state.lastStringValue = "";
|
|
while (isUnicodePropertyValueCharacter(ch = state.current())) {
|
|
state.lastStringValue += codePointToString$1(ch);
|
|
state.advance();
|
|
}
|
|
return state.lastStringValue !== ""
|
|
};
|
|
function isUnicodePropertyValueCharacter(ch) {
|
|
return isUnicodePropertyNameCharacter(ch) || isDecimalDigit(ch)
|
|
}
|
|
|
|
pp$9.regexp_eatLoneUnicodePropertyNameOrValue = function(state) {
|
|
return this.regexp_eatUnicodePropertyValue(state)
|
|
};
|
|
|
|
pp$9.regexp_eatCharacterClass = function(state) {
|
|
if (state.eat(0x5B )) {
|
|
state.eat(0x5E );
|
|
this.regexp_classRanges(state);
|
|
if (state.eat(0x5D )) {
|
|
return true
|
|
}
|
|
state.raise("Unterminated character class");
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_classRanges = function(state) {
|
|
var this$1 = this;
|
|
|
|
while (this.regexp_eatClassAtom(state)) {
|
|
var left = state.lastIntValue;
|
|
if (state.eat(0x2D ) && this$1.regexp_eatClassAtom(state)) {
|
|
var right = state.lastIntValue;
|
|
if (state.switchU && (left === -1 || right === -1)) {
|
|
state.raise("Invalid character class");
|
|
}
|
|
if (left !== -1 && right !== -1 && left > right) {
|
|
state.raise("Range out of order in character class");
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
pp$9.regexp_eatClassAtom = function(state) {
|
|
var start = state.pos;
|
|
|
|
if (state.eat(0x5C )) {
|
|
if (this.regexp_eatClassEscape(state)) {
|
|
return true
|
|
}
|
|
if (state.switchU) {
|
|
var ch$1 = state.current();
|
|
if (ch$1 === 0x63 || isOctalDigit(ch$1)) {
|
|
state.raise("Invalid class escape");
|
|
}
|
|
state.raise("Invalid escape");
|
|
}
|
|
state.pos = start;
|
|
}
|
|
|
|
var ch = state.current();
|
|
if (ch !== 0x5D ) {
|
|
state.lastIntValue = ch;
|
|
state.advance();
|
|
return true
|
|
}
|
|
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatClassEscape = function(state) {
|
|
var start = state.pos;
|
|
|
|
if (state.eat(0x62 )) {
|
|
state.lastIntValue = 0x08;
|
|
return true
|
|
}
|
|
|
|
if (state.switchU && state.eat(0x2D )) {
|
|
state.lastIntValue = 0x2D;
|
|
return true
|
|
}
|
|
|
|
if (!state.switchU && state.eat(0x63 )) {
|
|
if (this.regexp_eatClassControlLetter(state)) {
|
|
return true
|
|
}
|
|
state.pos = start;
|
|
}
|
|
|
|
return (
|
|
this.regexp_eatCharacterClassEscape(state) ||
|
|
this.regexp_eatCharacterEscape(state)
|
|
)
|
|
};
|
|
|
|
pp$9.regexp_eatClassControlLetter = function(state) {
|
|
var ch = state.current();
|
|
if (isDecimalDigit(ch) || ch === 0x5F ) {
|
|
state.lastIntValue = ch % 0x20;
|
|
state.advance();
|
|
return true
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatHexEscapeSequence = function(state) {
|
|
var start = state.pos;
|
|
if (state.eat(0x78 )) {
|
|
if (this.regexp_eatFixedHexDigits(state, 2)) {
|
|
return true
|
|
}
|
|
if (state.switchU) {
|
|
state.raise("Invalid escape");
|
|
}
|
|
state.pos = start;
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatDecimalDigits = function(state) {
|
|
var start = state.pos;
|
|
var ch = 0;
|
|
state.lastIntValue = 0;
|
|
while (isDecimalDigit(ch = state.current())) {
|
|
state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 );
|
|
state.advance();
|
|
}
|
|
return state.pos !== start
|
|
};
|
|
function isDecimalDigit(ch) {
|
|
return ch >= 0x30 && ch <= 0x39
|
|
}
|
|
|
|
pp$9.regexp_eatHexDigits = function(state) {
|
|
var start = state.pos;
|
|
var ch = 0;
|
|
state.lastIntValue = 0;
|
|
while (isHexDigit(ch = state.current())) {
|
|
state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);
|
|
state.advance();
|
|
}
|
|
return state.pos !== start
|
|
};
|
|
function isHexDigit(ch) {
|
|
return (
|
|
(ch >= 0x30 && ch <= 0x39 ) ||
|
|
(ch >= 0x41 && ch <= 0x46 ) ||
|
|
(ch >= 0x61 && ch <= 0x66 )
|
|
)
|
|
}
|
|
function hexToInt(ch) {
|
|
if (ch >= 0x41 && ch <= 0x46 ) {
|
|
return 10 + (ch - 0x41 )
|
|
}
|
|
if (ch >= 0x61 && ch <= 0x66 ) {
|
|
return 10 + (ch - 0x61 )
|
|
}
|
|
return ch - 0x30
|
|
}
|
|
|
|
pp$9.regexp_eatLegacyOctalEscapeSequence = function(state) {
|
|
if (this.regexp_eatOctalDigit(state)) {
|
|
var n1 = state.lastIntValue;
|
|
if (this.regexp_eatOctalDigit(state)) {
|
|
var n2 = state.lastIntValue;
|
|
if (n1 <= 3 && this.regexp_eatOctalDigit(state)) {
|
|
state.lastIntValue = n1 * 64 + n2 * 8 + state.lastIntValue;
|
|
} else {
|
|
state.lastIntValue = n1 * 8 + n2;
|
|
}
|
|
} else {
|
|
state.lastIntValue = n1;
|
|
}
|
|
return true
|
|
}
|
|
return false
|
|
};
|
|
|
|
pp$9.regexp_eatOctalDigit = function(state) {
|
|
var ch = state.current();
|
|
if (isOctalDigit(ch)) {
|
|
state.lastIntValue = ch - 0x30;
|
|
state.advance();
|
|
return true
|
|
}
|
|
state.lastIntValue = 0;
|
|
return false
|
|
};
|
|
function isOctalDigit(ch) {
|
|
return ch >= 0x30 && ch <= 0x37
|
|
}
|
|
|
|
pp$9.regexp_eatFixedHexDigits = function(state, length) {
|
|
var start = state.pos;
|
|
state.lastIntValue = 0;
|
|
for (var i = 0; i < length; ++i) {
|
|
var ch = state.current();
|
|
if (!isHexDigit(ch)) {
|
|
state.pos = start;
|
|
return false
|
|
}
|
|
state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);
|
|
state.advance();
|
|
}
|
|
return true
|
|
};
|
|
|
|
|
|
var Token = function Token(p) {
|
|
this.type = p.type;
|
|
this.value = p.value;
|
|
this.start = p.start;
|
|
this.end = p.end;
|
|
if (p.options.locations)
|
|
{ this.loc = new SourceLocation(p, p.startLoc, p.endLoc); }
|
|
if (p.options.ranges)
|
|
{ this.range = [p.start, p.end]; }
|
|
};
|
|
|
|
|
|
var pp$8 = Parser.prototype;
|
|
|
|
|
|
pp$8.next = function() {
|
|
if (this.options.onToken)
|
|
{ this.options.onToken(new Token(this)); }
|
|
|
|
this.lastTokEnd = this.end;
|
|
this.lastTokStart = this.start;
|
|
this.lastTokEndLoc = this.endLoc;
|
|
this.lastTokStartLoc = this.startLoc;
|
|
this.nextToken();
|
|
};
|
|
|
|
pp$8.getToken = function() {
|
|
this.next();
|
|
return new Token(this)
|
|
};
|
|
|
|
if (typeof Symbol !== "undefined")
|
|
{ pp$8[Symbol.iterator] = function() {
|
|
var this$1 = this;
|
|
|
|
return {
|
|
next: function () {
|
|
var token = this$1.getToken();
|
|
return {
|
|
done: token.type === types.eof,
|
|
value: token
|
|
}
|
|
}
|
|
}
|
|
}; }
|
|
|
|
|
|
pp$8.curContext = function() {
|
|
return this.context[this.context.length - 1]
|
|
};
|
|
|
|
|
|
pp$8.nextToken = function() {
|
|
var curContext = this.curContext();
|
|
if (!curContext || !curContext.preserveSpace) { this.skipSpace(); }
|
|
|
|
this.start = this.pos;
|
|
if (this.options.locations) { this.startLoc = this.curPosition(); }
|
|
if (this.pos >= this.input.length) { return this.finishToken(types.eof) }
|
|
|
|
if (curContext.override) { return curContext.override(this) }
|
|
else { this.readToken(this.fullCharCodeAtPos()); }
|
|
};
|
|
|
|
pp$8.readToken = function(code) {
|
|
if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 )
|
|
{ return this.readWord() }
|
|
|
|
return this.getTokenFromCode(code)
|
|
};
|
|
|
|
pp$8.fullCharCodeAtPos = function() {
|
|
var code = this.input.charCodeAt(this.pos);
|
|
if (code <= 0xd7ff || code >= 0xe000) { return code }
|
|
var next = this.input.charCodeAt(this.pos + 1);
|
|
return (code << 10) + next - 0x35fdc00
|
|
};
|
|
|
|
pp$8.skipBlockComment = function() {
|
|
var this$1 = this;
|
|
|
|
var startLoc = this.options.onComment && this.curPosition();
|
|
var start = this.pos, end = this.input.indexOf("*/", this.pos += 2);
|
|
if (end === -1) { this.raise(this.pos - 2, "Unterminated comment"); }
|
|
this.pos = end + 2;
|
|
if (this.options.locations) {
|
|
lineBreakG.lastIndex = start;
|
|
var match;
|
|
while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {
|
|
++this$1.curLine;
|
|
this$1.lineStart = match.index + match[0].length;
|
|
}
|
|
}
|
|
if (this.options.onComment)
|
|
{ this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,
|
|
startLoc, this.curPosition()); }
|
|
};
|
|
|
|
pp$8.skipLineComment = function(startSkip) {
|
|
var this$1 = this;
|
|
|
|
var start = this.pos;
|
|
var startLoc = this.options.onComment && this.curPosition();
|
|
var ch = this.input.charCodeAt(this.pos += startSkip);
|
|
while (this.pos < this.input.length && !isNewLine(ch)) {
|
|
ch = this$1.input.charCodeAt(++this$1.pos);
|
|
}
|
|
if (this.options.onComment)
|
|
{ this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,
|
|
startLoc, this.curPosition()); }
|
|
};
|
|
|
|
|
|
pp$8.skipSpace = function() {
|
|
var this$1 = this;
|
|
|
|
loop: while (this.pos < this.input.length) {
|
|
var ch = this$1.input.charCodeAt(this$1.pos);
|
|
switch (ch) {
|
|
case 32: case 160:
|
|
++this$1.pos;
|
|
break
|
|
case 13:
|
|
if (this$1.input.charCodeAt(this$1.pos + 1) === 10) {
|
|
++this$1.pos;
|
|
}
|
|
case 10: case 8232: case 8233:
|
|
++this$1.pos;
|
|
if (this$1.options.locations) {
|
|
++this$1.curLine;
|
|
this$1.lineStart = this$1.pos;
|
|
}
|
|
break
|
|
case 47:
|
|
switch (this$1.input.charCodeAt(this$1.pos + 1)) {
|
|
case 42:
|
|
this$1.skipBlockComment();
|
|
break
|
|
case 47:
|
|
this$1.skipLineComment(2);
|
|
break
|
|
default:
|
|
break loop
|
|
}
|
|
break
|
|
default:
|
|
if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
|
|
++this$1.pos;
|
|
} else {
|
|
break loop
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
pp$8.finishToken = function(type, val) {
|
|
this.end = this.pos;
|
|
if (this.options.locations) { this.endLoc = this.curPosition(); }
|
|
var prevType = this.type;
|
|
this.type = type;
|
|
this.value = val;
|
|
|
|
this.updateContext(prevType);
|
|
};
|
|
|
|
|
|
pp$8.readToken_dot = function() {
|
|
var next = this.input.charCodeAt(this.pos + 1);
|
|
if (next >= 48 && next <= 57) { return this.readNumber(true) }
|
|
var next2 = this.input.charCodeAt(this.pos + 2);
|
|
if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) {
|
|
this.pos += 3;
|
|
return this.finishToken(types.ellipsis)
|
|
} else {
|
|
++this.pos;
|
|
return this.finishToken(types.dot)
|
|
}
|
|
};
|
|
|
|
pp$8.readToken_slash = function() {
|
|
var next = this.input.charCodeAt(this.pos + 1);
|
|
if (this.exprAllowed) { ++this.pos; return this.readRegexp() }
|
|
if (next === 61) { return this.finishOp(types.assign, 2) }
|
|
return this.finishOp(types.slash, 1)
|
|
};
|
|
|
|
pp$8.readToken_mult_modulo_exp = function(code) {
|
|
var next = this.input.charCodeAt(this.pos + 1);
|
|
var size = 1;
|
|
var tokentype = code === 42 ? types.star : types.modulo;
|
|
|
|
if (this.options.ecmaVersion >= 7 && code === 42 && next === 42) {
|
|
++size;
|
|
tokentype = types.starstar;
|
|
next = this.input.charCodeAt(this.pos + 2);
|
|
}
|
|
|
|
if (next === 61) { return this.finishOp(types.assign, size + 1) }
|
|
return this.finishOp(tokentype, size)
|
|
};
|
|
|
|
pp$8.readToken_pipe_amp = function(code) {
|
|
var next = this.input.charCodeAt(this.pos + 1);
|
|
if (next === code) { return this.finishOp(code === 124 ? types.logicalOR : types.logicalAND, 2) }
|
|
if (next === 61) { return this.finishOp(types.assign, 2) }
|
|
return this.finishOp(code === 124 ? types.bitwiseOR : types.bitwiseAND, 1)
|
|
};
|
|
|
|
pp$8.readToken_caret = function() {
|
|
var next = this.input.charCodeAt(this.pos + 1);
|
|
if (next === 61) { return this.finishOp(types.assign, 2) }
|
|
return this.finishOp(types.bitwiseXOR, 1)
|
|
};
|
|
|
|
pp$8.readToken_plus_min = function(code) {
|
|
var next = this.input.charCodeAt(this.pos + 1);
|
|
if (next === code) {
|
|
if (next === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 &&
|
|
(this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd, this.pos)))) {
|
|
this.skipLineComment(3);
|
|
this.skipSpace();
|
|
return this.nextToken()
|
|
}
|
|
return this.finishOp(types.incDec, 2)
|
|
}
|
|
if (next === 61) { return this.finishOp(types.assign, 2) }
|
|
return this.finishOp(types.plusMin, 1)
|
|
};
|
|
|
|
pp$8.readToken_lt_gt = function(code) {
|
|
var next = this.input.charCodeAt(this.pos + 1);
|
|
var size = 1;
|
|
if (next === code) {
|
|
size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
|
|
if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types.assign, size + 1) }
|
|
return this.finishOp(types.bitShift, size)
|
|
}
|
|
if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 &&
|
|
this.input.charCodeAt(this.pos + 3) === 45) {
|
|
this.skipLineComment(4);
|
|
this.skipSpace();
|
|
return this.nextToken()
|
|
}
|
|
if (next === 61) { size = 2; }
|
|
return this.finishOp(types.relational, size)
|
|
};
|
|
|
|
pp$8.readToken_eq_excl = function(code) {
|
|
var next = this.input.charCodeAt(this.pos + 1);
|
|
if (next === 61) { return this.finishOp(types.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2) }
|
|
if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) {
|
|
this.pos += 2;
|
|
return this.finishToken(types.arrow)
|
|
}
|
|
return this.finishOp(code === 61 ? types.eq : types.prefix, 1)
|
|
};
|
|
|
|
pp$8.getTokenFromCode = function(code) {
|
|
switch (code) {
|
|
case 46:
|
|
return this.readToken_dot()
|
|
|
|
case 40: ++this.pos; return this.finishToken(types.parenL)
|
|
case 41: ++this.pos; return this.finishToken(types.parenR)
|
|
case 59: ++this.pos; return this.finishToken(types.semi)
|
|
case 44: ++this.pos; return this.finishToken(types.comma)
|
|
case 91: ++this.pos; return this.finishToken(types.bracketL)
|
|
case 93: ++this.pos; return this.finishToken(types.bracketR)
|
|
case 123: ++this.pos; return this.finishToken(types.braceL)
|
|
case 125: ++this.pos; return this.finishToken(types.braceR)
|
|
case 58: ++this.pos; return this.finishToken(types.colon)
|
|
case 63: ++this.pos; return this.finishToken(types.question)
|
|
|
|
case 96:
|
|
if (this.options.ecmaVersion < 6) { break }
|
|
++this.pos;
|
|
return this.finishToken(types.backQuote)
|
|
|
|
case 48:
|
|
var next = this.input.charCodeAt(this.pos + 1);
|
|
if (next === 120 || next === 88) { return this.readRadixNumber(16) }
|
|
if (this.options.ecmaVersion >= 6) {
|
|
if (next === 111 || next === 79) { return this.readRadixNumber(8) }
|
|
if (next === 98 || next === 66) { return this.readRadixNumber(2) }
|
|
}
|
|
|
|
case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
|
|
return this.readNumber(false)
|
|
|
|
case 34: case 39:
|
|
return this.readString(code)
|
|
|
|
|
|
case 47:
|
|
return this.readToken_slash()
|
|
|
|
case 37: case 42:
|
|
return this.readToken_mult_modulo_exp(code)
|
|
|
|
case 124: case 38:
|
|
return this.readToken_pipe_amp(code)
|
|
|
|
case 94:
|
|
return this.readToken_caret()
|
|
|
|
case 43: case 45:
|
|
return this.readToken_plus_min(code)
|
|
|
|
case 60: case 62:
|
|
return this.readToken_lt_gt(code)
|
|
|
|
case 61: case 33:
|
|
return this.readToken_eq_excl(code)
|
|
|
|
case 126:
|
|
return this.finishOp(types.prefix, 1)
|
|
}
|
|
|
|
this.raise(this.pos, "Unexpected character '" + codePointToString(code) + "'");
|
|
};
|
|
|
|
pp$8.finishOp = function(type, size) {
|
|
var str = this.input.slice(this.pos, this.pos + size);
|
|
this.pos += size;
|
|
return this.finishToken(type, str)
|
|
};
|
|
|
|
pp$8.readRegexp = function() {
|
|
var this$1 = this;
|
|
|
|
var escaped, inClass, start = this.pos;
|
|
for (;;) {
|
|
if (this$1.pos >= this$1.input.length) { this$1.raise(start, "Unterminated regular expression"); }
|
|
var ch = this$1.input.charAt(this$1.pos);
|
|
if (lineBreak.test(ch)) { this$1.raise(start, "Unterminated regular expression"); }
|
|
if (!escaped) {
|
|
if (ch === "[") { inClass = true; }
|
|
else if (ch === "]" && inClass) { inClass = false; }
|
|
else if (ch === "/" && !inClass) { break }
|
|
escaped = ch === "\\";
|
|
} else { escaped = false; }
|
|
++this$1.pos;
|
|
}
|
|
var pattern = this.input.slice(start, this.pos);
|
|
++this.pos;
|
|
var flagsStart = this.pos;
|
|
var flags = this.readWord1();
|
|
if (this.containsEsc) { this.unexpected(flagsStart); }
|
|
|
|
var state = this.regexpState || (this.regexpState = new RegExpValidationState(this));
|
|
state.reset(start, pattern, flags);
|
|
this.validateRegExpFlags(state);
|
|
this.validateRegExpPattern(state);
|
|
|
|
var value = null;
|
|
try {
|
|
value = new RegExp(pattern, flags);
|
|
} catch (e) {
|
|
}
|
|
|
|
return this.finishToken(types.regexp, {pattern: pattern, flags: flags, value: value})
|
|
};
|
|
|
|
|
|
pp$8.readInt = function(radix, len) {
|
|
var this$1 = this;
|
|
|
|
var start = this.pos, total = 0;
|
|
for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
|
|
var code = this$1.input.charCodeAt(this$1.pos), val = (void 0);
|
|
if (code >= 97) { val = code - 97 + 10; }
|
|
else if (code >= 65) { val = code - 65 + 10; }
|
|
else if (code >= 48 && code <= 57) { val = code - 48; }
|
|
else { val = Infinity; }
|
|
if (val >= radix) { break }
|
|
++this$1.pos;
|
|
total = total * radix + val;
|
|
}
|
|
if (this.pos === start || len != null && this.pos - start !== len) { return null }
|
|
|
|
return total
|
|
};
|
|
|
|
pp$8.readRadixNumber = function(radix) {
|
|
this.pos += 2;
|
|
var val = this.readInt(radix);
|
|
if (val == null) { this.raise(this.start + 2, "Expected number in radix " + radix); }
|
|
if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
|
|
return this.finishToken(types.num, val)
|
|
};
|
|
|
|
|
|
pp$8.readNumber = function(startsWithDot) {
|
|
var start = this.pos;
|
|
if (!startsWithDot && this.readInt(10) === null) { this.raise(start, "Invalid number"); }
|
|
var octal = this.pos - start >= 2 && this.input.charCodeAt(start) === 48;
|
|
if (octal && this.strict) { this.raise(start, "Invalid number"); }
|
|
if (octal && /[89]/.test(this.input.slice(start, this.pos))) { octal = false; }
|
|
var next = this.input.charCodeAt(this.pos);
|
|
if (next === 46 && !octal) {
|
|
++this.pos;
|
|
this.readInt(10);
|
|
next = this.input.charCodeAt(this.pos);
|
|
}
|
|
if ((next === 69 || next === 101) && !octal) {
|
|
next = this.input.charCodeAt(++this.pos);
|
|
if (next === 43 || next === 45) { ++this.pos; }
|
|
if (this.readInt(10) === null) { this.raise(start, "Invalid number"); }
|
|
}
|
|
if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, "Identifier directly after number"); }
|
|
|
|
var str = this.input.slice(start, this.pos);
|
|
var val = octal ? parseInt(str, 8) : parseFloat(str);
|
|
return this.finishToken(types.num, val)
|
|
};
|
|
|
|
|
|
pp$8.readCodePoint = function() {
|
|
var ch = this.input.charCodeAt(this.pos), code;
|
|
|
|
if (ch === 123) {
|
|
if (this.options.ecmaVersion < 6) { this.unexpected(); }
|
|
var codePos = ++this.pos;
|
|
code = this.readHexChar(this.input.indexOf("}", this.pos) - this.pos);
|
|
++this.pos;
|
|
if (code > 0x10FFFF) { this.invalidStringToken(codePos, "Code point out of bounds"); }
|
|
} else {
|
|
code = this.readHexChar(4);
|
|
}
|
|
return code
|
|
};
|
|
|
|
function codePointToString(code) {
|
|
if (code <= 0xFFFF) { return String.fromCharCode(code) }
|
|
code -= 0x10000;
|
|
return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00)
|
|
}
|
|
|
|
pp$8.readString = function(quote) {
|
|
var this$1 = this;
|
|
|
|
var out = "", chunkStart = ++this.pos;
|
|
for (;;) {
|
|
if (this$1.pos >= this$1.input.length) { this$1.raise(this$1.start, "Unterminated string constant"); }
|
|
var ch = this$1.input.charCodeAt(this$1.pos);
|
|
if (ch === quote) { break }
|
|
if (ch === 92) {
|
|
out += this$1.input.slice(chunkStart, this$1.pos);
|
|
out += this$1.readEscapedChar(false);
|
|
chunkStart = this$1.pos;
|
|
} else {
|
|
if (isNewLine(ch, this$1.options.ecmaVersion >= 10)) { this$1.raise(this$1.start, "Unterminated string constant"); }
|
|
++this$1.pos;
|
|
}
|
|
}
|
|
out += this.input.slice(chunkStart, this.pos++);
|
|
return this.finishToken(types.string, out)
|
|
};
|
|
|
|
|
|
var INVALID_TEMPLATE_ESCAPE_ERROR = {};
|
|
|
|
pp$8.tryReadTemplateToken = function() {
|
|
this.inTemplateElement = true;
|
|
try {
|
|
this.readTmplToken();
|
|
} catch (err) {
|
|
if (err === INVALID_TEMPLATE_ESCAPE_ERROR) {
|
|
this.readInvalidTemplateToken();
|
|
} else {
|
|
throw err
|
|
}
|
|
}
|
|
|
|
this.inTemplateElement = false;
|
|
};
|
|
|
|
pp$8.invalidStringToken = function(position, message) {
|
|
if (this.inTemplateElement && this.options.ecmaVersion >= 9) {
|
|
throw INVALID_TEMPLATE_ESCAPE_ERROR
|
|
} else {
|
|
this.raise(position, message);
|
|
}
|
|
};
|
|
|
|
pp$8.readTmplToken = function() {
|
|
var this$1 = this;
|
|
|
|
var out = "", chunkStart = this.pos;
|
|
for (;;) {
|
|
if (this$1.pos >= this$1.input.length) { this$1.raise(this$1.start, "Unterminated template"); }
|
|
var ch = this$1.input.charCodeAt(this$1.pos);
|
|
if (ch === 96 || ch === 36 && this$1.input.charCodeAt(this$1.pos + 1) === 123) {
|
|
if (this$1.pos === this$1.start && (this$1.type === types.template || this$1.type === types.invalidTemplate)) {
|
|
if (ch === 36) {
|
|
this$1.pos += 2;
|
|
return this$1.finishToken(types.dollarBraceL)
|
|
} else {
|
|
++this$1.pos;
|
|
return this$1.finishToken(types.backQuote)
|
|
}
|
|
}
|
|
out += this$1.input.slice(chunkStart, this$1.pos);
|
|
return this$1.finishToken(types.template, out)
|
|
}
|
|
if (ch === 92) {
|
|
out += this$1.input.slice(chunkStart, this$1.pos);
|
|
out += this$1.readEscapedChar(true);
|
|
chunkStart = this$1.pos;
|
|
} else if (isNewLine(ch)) {
|
|
out += this$1.input.slice(chunkStart, this$1.pos);
|
|
++this$1.pos;
|
|
switch (ch) {
|
|
case 13:
|
|
if (this$1.input.charCodeAt(this$1.pos) === 10) { ++this$1.pos; }
|
|
case 10:
|
|
out += "\n";
|
|
break
|
|
default:
|
|
out += String.fromCharCode(ch);
|
|
break
|
|
}
|
|
if (this$1.options.locations) {
|
|
++this$1.curLine;
|
|
this$1.lineStart = this$1.pos;
|
|
}
|
|
chunkStart = this$1.pos;
|
|
} else {
|
|
++this$1.pos;
|
|
}
|
|
}
|
|
};
|
|
|
|
pp$8.readInvalidTemplateToken = function() {
|
|
var this$1 = this;
|
|
|
|
for (; this.pos < this.input.length; this.pos++) {
|
|
switch (this$1.input[this$1.pos]) {
|
|
case "\\":
|
|
++this$1.pos;
|
|
break
|
|
|
|
case "$":
|
|
if (this$1.input[this$1.pos + 1] !== "{") {
|
|
break
|
|
}
|
|
|
|
case "`":
|
|
return this$1.finishToken(types.invalidTemplate, this$1.input.slice(this$1.start, this$1.pos))
|
|
|
|
}
|
|
}
|
|
this.raise(this.start, "Unterminated template");
|
|
};
|
|
|
|
|
|
pp$8.readEscapedChar = function(inTemplate) {
|
|
var ch = this.input.charCodeAt(++this.pos);
|
|
++this.pos;
|
|
switch (ch) {
|
|
case 110: return "\n"
|
|
case 114: return "\r"
|
|
case 120: return String.fromCharCode(this.readHexChar(2))
|
|
case 117: return codePointToString(this.readCodePoint())
|
|
case 116: return "\t"
|
|
case 98: return "\b"
|
|
case 118: return "\u000b"
|
|
case 102: return "\f"
|
|
case 13: if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; }
|
|
case 10:
|
|
if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }
|
|
return ""
|
|
default:
|
|
if (ch >= 48 && ch <= 55) {
|
|
var octalStr = this.input.substr(this.pos - 1, 3).match(/^[0-7]+/)[0];
|
|
var octal = parseInt(octalStr, 8);
|
|
if (octal > 255) {
|
|
octalStr = octalStr.slice(0, -1);
|
|
octal = parseInt(octalStr, 8);
|
|
}
|
|
this.pos += octalStr.length - 1;
|
|
ch = this.input.charCodeAt(this.pos);
|
|
if ((octalStr !== "0" || ch === 56 || ch === 57) && (this.strict || inTemplate)) {
|
|
this.invalidStringToken(
|
|
this.pos - 1 - octalStr.length,
|
|
inTemplate
|
|
? "Octal literal in template string"
|
|
: "Octal literal in strict mode"
|
|
);
|
|
}
|
|
return String.fromCharCode(octal)
|
|
}
|
|
return String.fromCharCode(ch)
|
|
}
|
|
};
|
|
|
|
|
|
pp$8.readHexChar = function(len) {
|
|
var codePos = this.pos;
|
|
var n = this.readInt(16, len);
|
|
if (n === null) { this.invalidStringToken(codePos, "Bad character escape sequence"); }
|
|
return n
|
|
};
|
|
|
|
|
|
pp$8.readWord1 = function() {
|
|
var this$1 = this;
|
|
|
|
this.containsEsc = false;
|
|
var word = "", first = true, chunkStart = this.pos;
|
|
var astral = this.options.ecmaVersion >= 6;
|
|
while (this.pos < this.input.length) {
|
|
var ch = this$1.fullCharCodeAtPos();
|
|
if (isIdentifierChar(ch, astral)) {
|
|
this$1.pos += ch <= 0xffff ? 1 : 2;
|
|
} else if (ch === 92) {
|
|
this$1.containsEsc = true;
|
|
word += this$1.input.slice(chunkStart, this$1.pos);
|
|
var escStart = this$1.pos;
|
|
if (this$1.input.charCodeAt(++this$1.pos) !== 117)
|
|
{ this$1.invalidStringToken(this$1.pos, "Expecting Unicode escape sequence \\uXXXX"); }
|
|
++this$1.pos;
|
|
var esc = this$1.readCodePoint();
|
|
if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))
|
|
{ this$1.invalidStringToken(escStart, "Invalid Unicode escape"); }
|
|
word += codePointToString(esc);
|
|
chunkStart = this$1.pos;
|
|
} else {
|
|
break
|
|
}
|
|
first = false;
|
|
}
|
|
return word + this.input.slice(chunkStart, this.pos)
|
|
};
|
|
|
|
|
|
pp$8.readWord = function() {
|
|
var word = this.readWord1();
|
|
var type = types.name;
|
|
if (this.keywords.test(word)) {
|
|
if (this.containsEsc) { this.raiseRecoverable(this.start, "Escape sequence in keyword " + word); }
|
|
type = keywords$1[word];
|
|
}
|
|
return this.finishToken(type, word)
|
|
};
|
|
|
|
|
|
var version = "5.7.3";
|
|
|
|
|
|
function parse(input, options) {
|
|
return new Parser(options, input).parse()
|
|
}
|
|
|
|
|
|
function parseExpressionAt(input, pos, options) {
|
|
var p = new Parser(options, input, pos);
|
|
p.nextToken();
|
|
return p.parseExpression()
|
|
}
|
|
|
|
|
|
function tokenizer(input, options) {
|
|
return new Parser(options, input)
|
|
}
|
|
|
|
function addLooseExports(parse, Parser$$1, plugins$$1) {
|
|
exports.parse_dammit = parse;
|
|
exports.LooseParser = Parser$$1;
|
|
exports.pluginsLoose = plugins$$1;
|
|
}
|
|
|
|
exports.version = version;
|
|
exports.parse = parse;
|
|
exports.parseExpressionAt = parseExpressionAt;
|
|
exports.tokenizer = tokenizer;
|
|
exports.addLooseExports = addLooseExports;
|
|
exports.Parser = Parser;
|
|
exports.plugins = plugins;
|
|
exports.defaultOptions = defaultOptions;
|
|
exports.Position = Position;
|
|
exports.SourceLocation = SourceLocation;
|
|
exports.getLineInfo = getLineInfo;
|
|
exports.Node = Node;
|
|
exports.TokenType = TokenType;
|
|
exports.tokTypes = types;
|
|
exports.keywordTypes = keywords$1;
|
|
exports.TokContext = TokContext;
|
|
exports.tokContexts = types$1;
|
|
exports.isIdentifierChar = isIdentifierChar;
|
|
exports.isIdentifierStart = isIdentifierStart;
|
|
exports.Token = Token;
|
|
exports.isNewLine = isNewLine;
|
|
exports.lineBreak = lineBreak;
|
|
exports.lineBreakG = lineBreakG;
|
|
exports.nonASCIIwhitespace = nonASCIIwhitespace;
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
})));
|
|
|
|
},{}],2:[function(require,module,exports){
|
|
|
|
},{}],3:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
function mock1D() {
|
|
const row = [];
|
|
for (let x = 0; x < this.output.x; x++) {
|
|
this.thread.x = x;
|
|
this.thread.y = 0;
|
|
this.thread.z = 0;
|
|
row.push(this._fn.apply(this, arguments));
|
|
}
|
|
return row;
|
|
}
|
|
|
|
function mock2D() {
|
|
const matrix = [];
|
|
for (let y = 0; y < this.output.y; y++) {
|
|
const row = [];
|
|
for (let x = 0; x < this.output.x; x++) {
|
|
this.thread.x = x;
|
|
this.thread.y = y;
|
|
this.thread.z = 0;
|
|
row.push(this._fn.apply(this, arguments));
|
|
}
|
|
matrix.push(row);
|
|
}
|
|
return matrix;
|
|
}
|
|
|
|
function mock3D() {
|
|
const cube = [];
|
|
for (let z = 0; z < this.output.z; z++) {
|
|
const matrix = [];
|
|
for (let y = 0; y < this.output.y; y++) {
|
|
const row = [];
|
|
for (let x = 0; x < this.output.x; x++) {
|
|
this.thread.x = x;
|
|
this.thread.y = y;
|
|
this.thread.z = z;
|
|
row.push(this._fn.apply(this, arguments));
|
|
}
|
|
matrix.push(row);
|
|
}
|
|
cube.push(matrix);
|
|
}
|
|
return cube;
|
|
}
|
|
|
|
module.exports = function gpuMock(fn, options) {
|
|
let contextOutput = null;
|
|
if (options.output.length) {
|
|
if (options.output.length === 3) {
|
|
contextOutput = { x: options.output[0], y: options.output[1], z: options.output[2] };
|
|
} else if (options.output.length === 2) {
|
|
contextOutput = { x: options.output[0], y: options.output[1] };
|
|
} else {
|
|
contextOutput = { x: options.output[0] };
|
|
}
|
|
} else {
|
|
contextOutput = options.output;
|
|
}
|
|
|
|
const context = {
|
|
_fn: fn,
|
|
constants: options.constants,
|
|
output: contextOutput,
|
|
thread: {
|
|
x: 0,
|
|
y: 0,
|
|
z: 0
|
|
}
|
|
};
|
|
|
|
if (contextOutput.z) {
|
|
return mock3D.bind(context);
|
|
} else if (contextOutput.y) {
|
|
return mock2D.bind(context);
|
|
} else {
|
|
return mock1D.bind(context);
|
|
}
|
|
};
|
|
|
|
},{}],4:[function(require,module,exports){
|
|
const {
|
|
utils
|
|
} = require('./utils');
|
|
|
|
function alias(name, source) {
|
|
const fnString = source.toString();
|
|
return new Function(`return function ${ name } (${ utils.getArgumentNamesFromString(fnString).join(', ') }) {
|
|
${ utils.getFunctionBodyFromString(fnString) }
|
|
}`)();
|
|
}
|
|
|
|
module.exports = {
|
|
alias
|
|
};
|
|
},{"./utils":29}],5:[function(require,module,exports){
|
|
const {
|
|
FunctionNode
|
|
} = require('../function-node');
|
|
|
|
class CPUFunctionNode extends FunctionNode {
|
|
astFunctionExpression(ast, retArr) {
|
|
|
|
if (!this.isRootKernel) {
|
|
retArr.push('function');
|
|
retArr.push(' ');
|
|
retArr.push(this.name);
|
|
retArr.push('(');
|
|
|
|
for (let i = 0; i < this.argumentNames.length; ++i) {
|
|
const argumentName = this.argumentNames[i];
|
|
|
|
if (i > 0) {
|
|
retArr.push(', ');
|
|
}
|
|
retArr.push('user_');
|
|
retArr.push(argumentName);
|
|
}
|
|
|
|
retArr.push(') {\n');
|
|
}
|
|
|
|
for (let i = 0; i < ast.body.body.length; ++i) {
|
|
this.astGeneric(ast.body.body[i], retArr);
|
|
retArr.push('\n');
|
|
}
|
|
|
|
if (!this.isRootKernel) {
|
|
retArr.push('}\n');
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
astReturnStatement(ast, retArr) {
|
|
if (this.isRootKernel) {
|
|
retArr.push('kernelResult = ');
|
|
this.astGeneric(ast.argument, retArr);
|
|
retArr.push(';');
|
|
} else if (this.isSubKernel) {
|
|
retArr.push(`subKernelResult_${ this.name } = `);
|
|
this.astGeneric(ast.argument, retArr);
|
|
retArr.push(';');
|
|
retArr.push(`return subKernelResult_${ this.name };`);
|
|
} else {
|
|
retArr.push('return ');
|
|
this.astGeneric(ast.argument, retArr);
|
|
retArr.push(';');
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
astLiteral(ast, retArr) {
|
|
|
|
if (isNaN(ast.value)) {
|
|
throw this.astErrorOutput(
|
|
'Non-numeric literal not supported : ' + ast.value,
|
|
ast
|
|
);
|
|
}
|
|
|
|
retArr.push(ast.value);
|
|
|
|
return retArr;
|
|
}
|
|
|
|
astBinaryExpression(ast, retArr) {
|
|
retArr.push('(');
|
|
this.astGeneric(ast.left, retArr);
|
|
retArr.push(ast.operator);
|
|
this.astGeneric(ast.right, retArr);
|
|
retArr.push(')');
|
|
return retArr;
|
|
}
|
|
|
|
astIdentifierExpression(idtNode, retArr) {
|
|
if (idtNode.type !== 'Identifier') {
|
|
throw this.astErrorOutput(
|
|
'IdentifierExpression - not an Identifier',
|
|
idtNode
|
|
);
|
|
}
|
|
|
|
switch (idtNode.name) {
|
|
case 'Infinity':
|
|
retArr.push('Infinity');
|
|
break;
|
|
default:
|
|
if (this.constants && this.constants.hasOwnProperty(idtNode.name)) {
|
|
retArr.push('constants_' + idtNode.name);
|
|
} else {
|
|
const name = this.getUserArgumentName(idtNode.name);
|
|
const type = this.getType(idtNode);
|
|
if (name && type && this.parent && type !== 'Number' && type !== 'Integer' && type !== 'LiteralInteger') {
|
|
retArr.push('user_' + name);
|
|
} else {
|
|
retArr.push('user_' + idtNode.name);
|
|
}
|
|
}
|
|
}
|
|
|
|
return retArr;
|
|
}
|
|
|
|
astForStatement(forNode, retArr) {
|
|
if (forNode.type !== 'ForStatement') {
|
|
throw this.astErrorOutput('Invalid for statement', forNode);
|
|
}
|
|
|
|
const initArr = [];
|
|
const testArr = [];
|
|
const updateArr = [];
|
|
const bodyArr = [];
|
|
let isSafe = null;
|
|
|
|
if (forNode.init) {
|
|
this.pushState('in-for-loop-init');
|
|
this.astGeneric(forNode.init, initArr);
|
|
for (let i = 0; i < initArr.length; i++) {
|
|
if (initArr[i].includes && initArr[i].includes(',')) {
|
|
isSafe = false;
|
|
}
|
|
}
|
|
this.popState('in-for-loop-init');
|
|
} else {
|
|
isSafe = false;
|
|
}
|
|
|
|
if (forNode.test) {
|
|
this.astGeneric(forNode.test, testArr);
|
|
} else {
|
|
isSafe = false;
|
|
}
|
|
|
|
if (forNode.update) {
|
|
this.astGeneric(forNode.update, updateArr);
|
|
} else {
|
|
isSafe = false;
|
|
}
|
|
|
|
if (forNode.body) {
|
|
this.pushState('loop-body');
|
|
this.astGeneric(forNode.body, bodyArr);
|
|
this.popState('loop-body');
|
|
}
|
|
|
|
if (isSafe === null) {
|
|
isSafe = this.isSafe(forNode.init) && this.isSafe(forNode.test);
|
|
}
|
|
|
|
if (isSafe) {
|
|
retArr.push(`for (${initArr.join('')};${testArr.join('')};${updateArr.join('')}){\n`);
|
|
retArr.push(bodyArr.join(''));
|
|
retArr.push('}\n');
|
|
} else {
|
|
const iVariableName = this.getInternalVariableName('safeI');
|
|
if (initArr.length > 0) {
|
|
retArr.push(initArr.join(''), ';\n');
|
|
}
|
|
retArr.push(`for (int ${iVariableName}=0;${iVariableName}<LOOP_MAX;${iVariableName}++){\n`);
|
|
if (testArr.length > 0) {
|
|
retArr.push(`if (!${testArr.join('')}) break;\n`);
|
|
}
|
|
retArr.push(bodyArr.join(''));
|
|
retArr.push(`\n${updateArr.join('')};`);
|
|
retArr.push('}\n');
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
astWhileStatement(whileNode, retArr) {
|
|
if (whileNode.type !== 'WhileStatement') {
|
|
throw this.astErrorOutput(
|
|
'Invalid while statement',
|
|
whileNode
|
|
);
|
|
}
|
|
|
|
retArr.push('for (let i = 0; i < LOOP_MAX; i++) {');
|
|
retArr.push('if (');
|
|
this.astGeneric(whileNode.test, retArr);
|
|
retArr.push(') {\n');
|
|
this.astGeneric(whileNode.body, retArr);
|
|
retArr.push('} else {\n');
|
|
retArr.push('break;\n');
|
|
retArr.push('}\n');
|
|
retArr.push('}\n');
|
|
|
|
return retArr;
|
|
}
|
|
|
|
astDoWhileStatement(doWhileNode, retArr) {
|
|
if (doWhileNode.type !== 'DoWhileStatement') {
|
|
throw this.astErrorOutput(
|
|
'Invalid while statement',
|
|
doWhileNode
|
|
);
|
|
}
|
|
|
|
retArr.push('for (let i = 0; i < LOOP_MAX; i++) {');
|
|
this.astGeneric(doWhileNode.body, retArr);
|
|
retArr.push('if (!');
|
|
this.astGeneric(doWhileNode.test, retArr);
|
|
retArr.push(') {\n');
|
|
retArr.push('break;\n');
|
|
retArr.push('}\n');
|
|
retArr.push('}\n');
|
|
|
|
return retArr;
|
|
|
|
}
|
|
|
|
astAssignmentExpression(assNode, retArr) {
|
|
this.astGeneric(assNode.left, retArr);
|
|
retArr.push(assNode.operator);
|
|
this.astGeneric(assNode.right, retArr);
|
|
return retArr;
|
|
}
|
|
|
|
astBlockStatement(bNode, retArr) {
|
|
if (!this.isState('loop-body')) {
|
|
retArr.push('{\n');
|
|
}
|
|
for (let i = 0; i < bNode.body.length; i++) {
|
|
this.astGeneric(bNode.body[i], retArr);
|
|
}
|
|
if (!this.isState('loop-body')) {
|
|
retArr.push('}\n');
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
astVariableDeclaration(varDecNode, retArr) {
|
|
if (varDecNode.kind === 'var') {
|
|
this.varWarn();
|
|
}
|
|
retArr.push(`${varDecNode.kind} `);
|
|
const firstDeclaration = varDecNode.declarations[0];
|
|
const type = this.getType(firstDeclaration.init);
|
|
for (let i = 0; i < varDecNode.declarations.length; i++) {
|
|
this.declarations[varDecNode.declarations[i].id.name] = {
|
|
type,
|
|
dependencies: {
|
|
constants: [],
|
|
arguments: []
|
|
},
|
|
isUnsafe: false
|
|
};
|
|
if (i > 0) {
|
|
retArr.push(',');
|
|
}
|
|
this.astGeneric(varDecNode.declarations[i], retArr);
|
|
}
|
|
if (!this.isState('in-for-loop-init')) {
|
|
retArr.push(';');
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
astIfStatement(ifNode, retArr) {
|
|
retArr.push('if (');
|
|
this.astGeneric(ifNode.test, retArr);
|
|
retArr.push(')');
|
|
if (ifNode.consequent.type === 'BlockStatement') {
|
|
this.astGeneric(ifNode.consequent, retArr);
|
|
} else {
|
|
retArr.push(' {\n');
|
|
this.astGeneric(ifNode.consequent, retArr);
|
|
retArr.push('\n}\n');
|
|
}
|
|
|
|
if (ifNode.alternate) {
|
|
retArr.push('else ');
|
|
if (ifNode.alternate.type === 'BlockStatement') {
|
|
this.astGeneric(ifNode.alternate, retArr);
|
|
} else {
|
|
retArr.push(' {\n');
|
|
this.astGeneric(ifNode.alternate, retArr);
|
|
retArr.push('\n}\n');
|
|
}
|
|
}
|
|
return retArr;
|
|
|
|
}
|
|
|
|
astThisExpression(tNode, retArr) {
|
|
retArr.push('_this');
|
|
return retArr;
|
|
}
|
|
|
|
astMemberExpression(mNode, retArr) {
|
|
const {
|
|
signature,
|
|
type,
|
|
property,
|
|
xProperty,
|
|
yProperty,
|
|
zProperty,
|
|
name,
|
|
origin
|
|
} = this.getMemberExpressionDetails(mNode);
|
|
switch (signature) {
|
|
case 'this.thread.value':
|
|
retArr.push(`_this.thread.${ name }`);
|
|
return retArr;
|
|
case 'this.output.value':
|
|
switch (name) {
|
|
case 'x':
|
|
retArr.push(this.output[0]);
|
|
break;
|
|
case 'y':
|
|
retArr.push(this.output[1]);
|
|
break;
|
|
case 'z':
|
|
retArr.push(this.output[2]);
|
|
break;
|
|
default:
|
|
throw this.astErrorOutput('Unexpected expression', mNode);
|
|
}
|
|
return retArr;
|
|
case 'value':
|
|
throw this.astErrorOutput('Unexpected expression', mNode);
|
|
case 'value[]':
|
|
case 'value[][]':
|
|
case 'value[][][]':
|
|
case 'value.value':
|
|
if (origin === 'Math') {
|
|
retArr.push(Math[name]);
|
|
return retArr;
|
|
}
|
|
switch (property) {
|
|
case 'r':
|
|
retArr.push(`user_${ name }[0]`);
|
|
return retArr;
|
|
case 'g':
|
|
retArr.push(`user_${ name }[1]`);
|
|
return retArr;
|
|
case 'b':
|
|
retArr.push(`user_${ name }[2]`);
|
|
return retArr;
|
|
case 'a':
|
|
retArr.push(`user_${ name }[3]`);
|
|
return retArr;
|
|
}
|
|
break;
|
|
case 'this.constants.value':
|
|
case 'this.constants.value[]':
|
|
case 'this.constants.value[][]':
|
|
case 'this.constants.value[][][]':
|
|
break;
|
|
case 'fn()[]':
|
|
this.astGeneric(mNode.object, retArr);
|
|
retArr.push('[');
|
|
this.astGeneric(mNode.property, retArr);
|
|
retArr.push(']');
|
|
return retArr;
|
|
default:
|
|
throw this.astErrorOutput('Unexpected expression', mNode);
|
|
}
|
|
|
|
if (type === 'Number' || type === 'Integer') {
|
|
retArr.push(`${origin}_${name}`);
|
|
return retArr;
|
|
}
|
|
|
|
let synonymName;
|
|
if (this.parent) {
|
|
synonymName = this.getUserArgumentName(name);
|
|
}
|
|
|
|
const markupName = `${origin}_${synonymName || name}`;
|
|
|
|
switch (type) {
|
|
case 'Array(2)':
|
|
case 'Array(3)':
|
|
case 'Array(4)':
|
|
case 'HTMLImageArray':
|
|
case 'ArrayTexture(4)':
|
|
case 'HTMLImage':
|
|
default:
|
|
const isInput = this.isInput(synonymName || name);
|
|
retArr.push(`${ markupName }`);
|
|
if (zProperty && yProperty) {
|
|
if (isInput) {
|
|
const size = this.argumentSizes[this.argumentNames.indexOf(name)];
|
|
retArr.push('[(');
|
|
this.astGeneric(zProperty, retArr);
|
|
retArr.push(`*${ size[1] * size[0]})+(`);
|
|
this.astGeneric(yProperty, retArr);
|
|
retArr.push(`*${ size[0] })+`);
|
|
this.astGeneric(xProperty, retArr);
|
|
retArr.push(']');
|
|
} else {
|
|
retArr.push('[');
|
|
this.astGeneric(zProperty, retArr);
|
|
retArr.push(']');
|
|
retArr.push('[');
|
|
this.astGeneric(yProperty, retArr);
|
|
retArr.push(']');
|
|
retArr.push('[');
|
|
this.astGeneric(xProperty, retArr);
|
|
retArr.push(']');
|
|
}
|
|
} else if (yProperty) {
|
|
if (isInput) {
|
|
const size = this.argumentSizes[this.argumentNames.indexOf(name)];
|
|
retArr.push('[(');
|
|
this.astGeneric(yProperty, retArr);
|
|
retArr.push(`*${ size[0] })+`);
|
|
this.astGeneric(xProperty, retArr);
|
|
retArr.push(']');
|
|
} else {
|
|
retArr.push('[');
|
|
this.astGeneric(yProperty, retArr);
|
|
retArr.push(']');
|
|
retArr.push('[');
|
|
this.astGeneric(xProperty, retArr);
|
|
retArr.push(']');
|
|
}
|
|
} else {
|
|
retArr.push('[');
|
|
this.astGeneric(xProperty, retArr);
|
|
retArr.push(']');
|
|
}
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
astCallExpression(ast, retArr) {
|
|
if (ast.callee) {
|
|
let funcName = this.astMemberExpressionUnroll(ast.callee);
|
|
|
|
if (this.calledFunctions.indexOf(funcName) < 0) {
|
|
this.calledFunctions.push(funcName);
|
|
}
|
|
if (!this.calledFunctionsArguments[funcName]) {
|
|
this.calledFunctionsArguments[funcName] = [];
|
|
}
|
|
|
|
const functionArguments = [];
|
|
this.calledFunctionsArguments[funcName].push(functionArguments);
|
|
|
|
retArr.push(funcName);
|
|
|
|
retArr.push('(');
|
|
|
|
for (let i = 0; i < ast.arguments.length; ++i) {
|
|
const argument = ast.arguments[i];
|
|
if (i > 0) {
|
|
retArr.push(', ');
|
|
}
|
|
this.astGeneric(argument, retArr);
|
|
const argumentType = this.getType(argument);
|
|
if (argumentType) {
|
|
functionArguments.push({
|
|
name: argument.name || null,
|
|
type: argumentType
|
|
});
|
|
} else {
|
|
functionArguments.push(null);
|
|
}
|
|
}
|
|
|
|
retArr.push(')');
|
|
|
|
return retArr;
|
|
}
|
|
|
|
throw this.astErrorOutput(
|
|
'Unknown CallExpression',
|
|
ast
|
|
);
|
|
}
|
|
|
|
astArrayExpression(arrNode, retArr) {
|
|
const arrLen = arrNode.elements.length;
|
|
|
|
retArr.push('[');
|
|
for (let i = 0; i < arrLen; ++i) {
|
|
if (i > 0) {
|
|
retArr.push(', ');
|
|
}
|
|
const subNode = arrNode.elements[i];
|
|
this.astGeneric(subNode, retArr)
|
|
}
|
|
retArr.push(']');
|
|
|
|
return retArr;
|
|
}
|
|
|
|
astDebuggerStatement(arrNode, retArr) {
|
|
retArr.push('debugger;');
|
|
return retArr;
|
|
}
|
|
|
|
varWarn() {
|
|
console.warn('var declarations are not supported, weird things happen. Use const or let');
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
CPUFunctionNode
|
|
};
|
|
},{"../function-node":9}],6:[function(require,module,exports){
|
|
const {
|
|
utils
|
|
} = require('../../utils');
|
|
const {
|
|
kernelRunShortcut
|
|
} = require('../../kernel-run-shortcut');
|
|
|
|
function removeFnNoise(fn) {
|
|
if (/^function /.test(fn)) {
|
|
fn = fn.substring(9);
|
|
}
|
|
return fn.replace(/[_]typeof/g, 'typeof');
|
|
}
|
|
|
|
function removeNoise(str) {
|
|
return str
|
|
.replace(/^[A-Za-z]+/, 'function')
|
|
.replace(/[_]typeof/g, 'typeof');
|
|
}
|
|
|
|
function cpuKernelString(cpuKernel, name) {
|
|
return `() => {
|
|
${ kernelRunShortcut.toString() };
|
|
const utils = {
|
|
allPropertiesOf: ${ removeNoise(utils.allPropertiesOf.toString()) },
|
|
clone: ${ removeNoise(utils.clone.toString()) },
|
|
};
|
|
let Input = function() {};
|
|
class ${ name || 'Kernel' } {
|
|
constructor() {
|
|
this.argumentsLength = 0;
|
|
this.canvas = null;
|
|
this.context = null;
|
|
this.built = false;
|
|
this.program = null;
|
|
this.argumentNames = ${ JSON.stringify(cpuKernel.argumentNames) };
|
|
this.argumentTypes = ${ JSON.stringify(cpuKernel.argumentTypes) };
|
|
this.argumentSizes = ${ JSON.stringify(cpuKernel.argumentSizes) };
|
|
this.output = ${ JSON.stringify(cpuKernel.output) };
|
|
this._kernelString = \`${ cpuKernel._kernelString }\`;
|
|
this.output = ${ JSON.stringify(cpuKernel.output) };
|
|
this.run = function() {
|
|
this.run = null;
|
|
this.build(arguments);
|
|
return this.run.apply(this, arguments);
|
|
}.bind(this);
|
|
this.thread = {
|
|
x: 0,
|
|
y: 0,
|
|
z: 0
|
|
};
|
|
}
|
|
setCanvas(canvas) { this.canvas = canvas; return this; }
|
|
setContext(context) { this.context = context; return this; }
|
|
setInput(Type) { Input = Type; }
|
|
${ removeFnNoise(cpuKernel.build.toString()) }
|
|
setupArguments() {}
|
|
${ removeFnNoise(cpuKernel.setupConstants.toString()) }
|
|
run () { ${ cpuKernel.kernelString } }
|
|
getKernelString() { return this._kernelString; }
|
|
${ removeFnNoise(cpuKernel.validateSettings.toString()) }
|
|
${ removeFnNoise(cpuKernel.checkOutput.toString()) }
|
|
};
|
|
return kernelRunShortcut(new Kernel());
|
|
};`;
|
|
}
|
|
|
|
module.exports = {
|
|
cpuKernelString
|
|
};
|
|
},{"../../kernel-run-shortcut":26,"../../utils":29}],7:[function(require,module,exports){
|
|
const {
|
|
Kernel
|
|
} = require('../kernel');
|
|
const {
|
|
FunctionBuilder
|
|
} = require('../function-builder');
|
|
const {
|
|
CPUFunctionNode
|
|
} = require('./function-node');
|
|
const {
|
|
utils
|
|
} = require('../../utils');
|
|
const {
|
|
cpuKernelString
|
|
} = require('./kernel-string');
|
|
|
|
class CPUKernel extends Kernel {
|
|
static getFeatures() {
|
|
return this.features;
|
|
}
|
|
static get features() {
|
|
return Object.freeze({
|
|
kernelMap: true,
|
|
isIntegerDivisionAccurate: true
|
|
});
|
|
}
|
|
static get isSupported() {
|
|
return true;
|
|
}
|
|
static isContextMatch(context) {
|
|
return false;
|
|
}
|
|
static get mode() {
|
|
return 'cpu';
|
|
}
|
|
|
|
constructor(source, settings) {
|
|
super(source, settings);
|
|
|
|
this.mergeSettings(source.settings || settings);
|
|
|
|
this._imageData = null;
|
|
this._colorData = null;
|
|
this._kernelString = null;
|
|
this.thread = {
|
|
x: 0,
|
|
y: 0,
|
|
z: 0
|
|
};
|
|
|
|
this.run = function() {
|
|
this.run = null;
|
|
this.build.apply(this, arguments);
|
|
return this.run.apply(this, arguments);
|
|
}.bind(this);
|
|
}
|
|
|
|
initCanvas() {
|
|
if (typeof document !== 'undefined') {
|
|
return document.createElement('canvas');
|
|
} else if (typeof OffscreenCanvas !== 'undefined') {
|
|
return new OffscreenCanvas(0, 0);
|
|
}
|
|
}
|
|
|
|
initContext() {
|
|
if (!this.canvas) return null;
|
|
return this.canvas.getContext('2d');
|
|
}
|
|
|
|
initPlugins(settings) {
|
|
return [];
|
|
}
|
|
|
|
validateSettings() {
|
|
if (!this.output || this.output.length === 0) {
|
|
if (arguments.length !== 1) {
|
|
throw 'Auto dimensions only supported for kernels with only one input';
|
|
}
|
|
|
|
const argType = utils.getVariableType(arguments[0]);
|
|
if (argType === 'Array') {
|
|
this.output = utils.getDimensions(argType);
|
|
} else if (argType === 'NumberTexture' || argType === 'ArrayTexture(4)') {
|
|
this.output = arguments[0].output;
|
|
} else {
|
|
throw 'Auto dimensions not supported for input type: ' + argType;
|
|
}
|
|
}
|
|
|
|
this.checkOutput();
|
|
}
|
|
|
|
build() {
|
|
this.setupConstants();
|
|
this.setupArguments(arguments);
|
|
this.validateSettings();
|
|
|
|
if (this.graphical) {
|
|
const {
|
|
canvas,
|
|
output
|
|
} = this;
|
|
if (!canvas) {
|
|
throw new Error('no canvas available for using graphical output');
|
|
}
|
|
const width = output[0];
|
|
const height = output[1] || 1;
|
|
canvas.width = width;
|
|
canvas.height = height;
|
|
this._imageData = this.context.createImageData(width, height);
|
|
this._colorData = new Uint8ClampedArray(width * height * 4);
|
|
}
|
|
|
|
const kernelString = this.getKernelString();
|
|
this.kernelString = kernelString;
|
|
|
|
if (this.debug) {
|
|
console.log('Function output:');
|
|
console.log(kernelString);
|
|
}
|
|
|
|
try {
|
|
this.run = new Function([], kernelString).bind(this)();
|
|
} catch (e) {
|
|
console.error('An error occurred compiling the javascript: ', e);
|
|
}
|
|
}
|
|
|
|
color(r, g, b, a) {
|
|
if (typeof a === 'undefined') {
|
|
a = 1;
|
|
}
|
|
|
|
r = Math.floor(r * 255);
|
|
g = Math.floor(g * 255);
|
|
b = Math.floor(b * 255);
|
|
a = Math.floor(a * 255);
|
|
|
|
const width = this.output[0];
|
|
const height = this.output[1];
|
|
|
|
const x = this.thread.x;
|
|
const y = height - this.thread.y - 1;
|
|
|
|
const index = x + y * width;
|
|
|
|
this._colorData[index * 4 + 0] = r;
|
|
this._colorData[index * 4 + 1] = g;
|
|
this._colorData[index * 4 + 2] = b;
|
|
this._colorData[index * 4 + 3] = a;
|
|
}
|
|
|
|
getKernelString() {
|
|
if (this._kernelString !== null) return this._kernelString;
|
|
|
|
const functionBuilder = FunctionBuilder.fromKernel(this, CPUFunctionNode);
|
|
|
|
let prototypes = functionBuilder.getPrototypes('kernel');
|
|
let kernel = null;
|
|
if (prototypes.length > 1) {
|
|
prototypes = prototypes.filter(fn => {
|
|
if (/^function/.test(fn)) return fn;
|
|
kernel = fn;
|
|
return false;
|
|
})
|
|
} else {
|
|
kernel = prototypes.shift();
|
|
}
|
|
const kernelString = this._kernelString = `
|
|
const LOOP_MAX = ${ this._getLoopMaxString() }
|
|
const constants = this.constants;
|
|
const _this = this;
|
|
return function (${ this.argumentNames.map(argumentName => 'user_' + argumentName).join(', ') }) {
|
|
${ this._processConstants() }
|
|
${ this._processArguments() }
|
|
${ this._kernelLoop(kernel) }
|
|
if (this.graphical) {
|
|
this._imageData.data.set(this._colorData);
|
|
this.context.putImageData(this._imageData, 0, 0);
|
|
return;
|
|
}
|
|
${ this._kernelOutput() }
|
|
${ prototypes.length > 0 ? prototypes.join('\n') : '' }
|
|
}.bind(this);`;
|
|
return kernelString;
|
|
}
|
|
|
|
toString() {
|
|
return cpuKernelString(this);
|
|
}
|
|
|
|
_getLoopMaxString() {
|
|
return (
|
|
this.loopMaxIterations ?
|
|
` ${ parseInt(this.loopMaxIterations) };\n` :
|
|
' 1000;\n'
|
|
);
|
|
}
|
|
|
|
_processConstants() {
|
|
if (!this.constants) return '';
|
|
|
|
const result = [];
|
|
for (let p in this.constants) {
|
|
const type = this.constantTypes[p];
|
|
switch (type) {
|
|
case 'HTMLImage':
|
|
result.push(` const constants_${p} = this._imageTo2DArray(this.constants.${p});`);
|
|
break;
|
|
case 'HTMLImageArray':
|
|
result.push(` const constants_${p} = this._imageTo3DArray(this.constants.${p});`);
|
|
break;
|
|
case 'Input':
|
|
result.push(` const constants_${p} = this.constants.${p}.value;`);
|
|
break;
|
|
default:
|
|
result.push(` const constants_${p} = this.constants.${p};`);
|
|
}
|
|
}
|
|
return result.join('\n');
|
|
}
|
|
|
|
_processArguments() {
|
|
const result = [];
|
|
for (let i = 0; i < this.argumentTypes.length; i++) {
|
|
switch (this.argumentTypes[i]) {
|
|
case 'HTMLImage':
|
|
result.push(` user_${this.argumentNames[i]} = this._imageTo2DArray(user_${this.argumentNames[i]});`);
|
|
break;
|
|
case 'HTMLImageArray':
|
|
result.push(` user_${this.argumentNames[i]} = this._imageTo3DArray(user_${this.argumentNames[i]});`);
|
|
break;
|
|
case 'Input':
|
|
result.push(` user_${this.argumentNames[i]} = user_${this.argumentNames[i]}.value;`);
|
|
break;
|
|
}
|
|
}
|
|
return result.join(';\n');
|
|
}
|
|
|
|
_imageTo2DArray(image) {
|
|
const canvas = this.canvas;
|
|
if (canvas.width < image.width) {
|
|
canvas.width = image.width;
|
|
}
|
|
if (canvas.height < image.height) {
|
|
canvas.height = image.height;
|
|
}
|
|
const ctx = this.context;
|
|
ctx.drawImage(image, 0, 0, image.width, image.height);
|
|
const pixelsData = ctx.getImageData(0, 0, image.width, image.height).data;
|
|
const imageArray = new Array(image.height);
|
|
let index = 0;
|
|
for (let y = image.height - 1; y >= 0; y--) {
|
|
imageArray[y] = new Array(image.width);
|
|
for (let x = 0; x < image.width; x++) {
|
|
const r = pixelsData[index++] / 255;
|
|
const g = pixelsData[index++] / 255;
|
|
const b = pixelsData[index++] / 255;
|
|
const a = pixelsData[index++] / 255;
|
|
imageArray[y][x] = [r, g, b, a];
|
|
}
|
|
}
|
|
return imageArray;
|
|
}
|
|
|
|
_imageTo3DArray(images) {
|
|
const imagesArray = new Array(images.length);
|
|
for (let i = 0; i < images.length; i++) {
|
|
imagesArray[i] = this._imageTo2DArray(images[i]);
|
|
}
|
|
return imagesArray;
|
|
}
|
|
|
|
_kernelLoop(kernelString) {
|
|
switch (this.output.length) {
|
|
case 1:
|
|
return this._kernel1DLoop(kernelString);
|
|
case 2:
|
|
return this._kernel2DLoop(kernelString);
|
|
case 3:
|
|
return this._kernel3DLoop(kernelString);
|
|
default:
|
|
throw new Error('unsupported size kernel');
|
|
}
|
|
}
|
|
|
|
_kernel1DLoop(kernelString) {
|
|
const {
|
|
output
|
|
} = this;
|
|
return `const result = new Float32Array(${ output[0] });
|
|
${ this._mapSubKernels(subKernel => `let subKernelResult_${ subKernel.name };`).join('\n') }
|
|
${ this._mapSubKernels(subKernel => `const result_${ subKernel.name } = new Float32Array(${ output[0] });\n`).join('') }
|
|
for (let x = 0; x < ${ output[0] }; x++) {
|
|
this.thread.x = x;
|
|
this.thread.y = 0;
|
|
this.thread.z = 0;
|
|
let kernelResult;
|
|
${ kernelString }
|
|
result[x] = kernelResult;
|
|
${ this._mapSubKernels(subKernel => `result_${ subKernel.name }[x] = subKernelResult_${ subKernel.name };\n`).join('') }
|
|
}`;
|
|
}
|
|
|
|
_kernel2DLoop(kernelString) {
|
|
const {
|
|
output
|
|
} = this;
|
|
return `const result = new Array(${ output[1] });
|
|
${ this._mapSubKernels(subKernel => `let subKernelResult_${ subKernel.name };`).join('\n') }
|
|
${ this._mapSubKernels(subKernel => `const result_${ subKernel.name } = new Array(${ output[1] });\n`).join('') }
|
|
for (let y = 0; y < ${ output[1] }; y++) {
|
|
this.thread.z = 0;
|
|
this.thread.y = y;
|
|
const resultX = result[y] = new Float32Array(${ output[0] });
|
|
${ this._mapSubKernels(subKernel => `const result_${ subKernel.name }X = result_${subKernel.name}[y] = new Float32Array(${ output[0] });\n`).join('') }
|
|
for (let x = 0; x < ${ output[0] }; x++) {
|
|
this.thread.x = x;
|
|
let kernelResult;
|
|
${ kernelString }
|
|
resultX[x] = kernelResult;
|
|
${ this._mapSubKernels(subKernel => `result_${ subKernel.name }X[x] = subKernelResult_${ subKernel.name };\n`).join('') }
|
|
}
|
|
}`;
|
|
}
|
|
|
|
_kernel3DLoop(kernelString) {
|
|
const {
|
|
output
|
|
} = this;
|
|
return `const result = new Array(${ output[2] });
|
|
${ this._mapSubKernels(subKernel => `let subKernelResult_${ subKernel.name };`).join('\n') }
|
|
${ this._mapSubKernels(subKernel => `const result_${ subKernel.name } = new Array(${ output[2] });\n`).join('') }
|
|
for (let z = 0; z < ${ output[2] }; z++) {
|
|
this.thread.z = z;
|
|
const resultY = result[z] = new Array(${ output[1] });
|
|
${ this._mapSubKernels(subKernel => `const result_${ subKernel.name }Y = result_${subKernel.name}[z] = new Array(${ output[1] });\n`).join('') }
|
|
for (let y = 0; y < ${ output[1] }; y++) {
|
|
this.thread.y = y;
|
|
const resultX = resultY[y] = new Float32Array(${ output[0] });
|
|
${ this._mapSubKernels(subKernel => `const result_${ subKernel.name }X = result_${subKernel.name}Y[y] = new Float32Array(${ output[0] });\n`).join('') }
|
|
for (let x = 0; x < ${ output[0] }; x++) {
|
|
this.thread.x = x;
|
|
let kernelResult;
|
|
${ kernelString }
|
|
resultX[x] = kernelResult;
|
|
${ this._mapSubKernels(subKernel => `result_${ subKernel.name }X[x] = subKernelResult_${ subKernel.name };\n`).join('') }
|
|
}
|
|
}
|
|
}`;
|
|
}
|
|
|
|
_kernelOutput() {
|
|
if (!this.subKernels) {
|
|
return 'return result;';
|
|
}
|
|
return `return {
|
|
result: result,
|
|
${ this.subKernels.map(subKernel => `${ subKernel.property }: result_${ subKernel.name }`).join(',\n') }
|
|
};`;
|
|
}
|
|
|
|
_mapSubKernels(fn) {
|
|
return this.subKernels === null ? [''] :
|
|
this.subKernels.map(fn);
|
|
}
|
|
|
|
destroy(removeCanvasReference) {
|
|
if (removeCanvasReference) {
|
|
delete this.canvas;
|
|
}
|
|
}
|
|
|
|
static destroyContext(context) {}
|
|
|
|
toJSON() {
|
|
const json = super.toJSON();
|
|
json.functionNodes = FunctionBuilder.fromKernel(this, CPUFunctionNode).toJSON();
|
|
return json;
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
CPUKernel
|
|
};
|
|
},{"../../utils":29,"../function-builder":8,"../kernel":12,"./function-node":5,"./kernel-string":6}],8:[function(require,module,exports){
|
|
class FunctionBuilder {
|
|
static fromKernel(kernel, FunctionNode, extraNodeOptions) {
|
|
const {
|
|
argumentNames,
|
|
argumentTypes,
|
|
argumentSizes,
|
|
constants,
|
|
constantTypes,
|
|
debug,
|
|
loopMaxIterations,
|
|
nativeFunctions,
|
|
output,
|
|
plugins,
|
|
source,
|
|
subKernels,
|
|
functions,
|
|
} = kernel;
|
|
|
|
const onNestedFunction = (fnString, returnType) => {
|
|
functionBuilder.addFunctionNode(new FunctionNode(fnString, Object.assign({}, nodeOptions, {
|
|
returnType
|
|
})));
|
|
};
|
|
|
|
const lookupReturnType = (functionName) => {
|
|
return functionBuilder.lookupReturnType(functionName);
|
|
};
|
|
|
|
const nodeOptions = Object.assign({
|
|
isRootKernel: false,
|
|
onNestedFunction,
|
|
lookupReturnType,
|
|
constants,
|
|
constantTypes,
|
|
debug,
|
|
loopMaxIterations,
|
|
output,
|
|
plugins,
|
|
}, extraNodeOptions || {});
|
|
|
|
const rootNodeOptions = Object.assign({}, nodeOptions, {
|
|
isRootKernel: true,
|
|
name: 'kernel',
|
|
argumentNames,
|
|
argumentTypes,
|
|
argumentSizes,
|
|
});
|
|
|
|
if (typeof source === 'object' && source.functionNodes) {
|
|
return new FunctionBuilder().fromJSON(source.functionNodes, FunctionNode);
|
|
}
|
|
|
|
const rootNode = new FunctionNode(source, rootNodeOptions);
|
|
|
|
let functionNodes = null;
|
|
if (functions) {
|
|
functionNodes = functions.map((fn) => new FunctionNode(fn.source, {
|
|
returnType: fn.returnType,
|
|
argumentTypes: fn.argumentTypes,
|
|
output,
|
|
plugins,
|
|
constants,
|
|
constantTypes,
|
|
}));
|
|
}
|
|
|
|
let subKernelNodes = null;
|
|
if (subKernels) {
|
|
subKernelNodes = subKernels.map((subKernel) => {
|
|
const {
|
|
name,
|
|
source
|
|
} = subKernel;
|
|
return new FunctionNode(source, Object.assign({}, nodeOptions, {
|
|
name,
|
|
isSubKernel: true,
|
|
isRootKernel: false
|
|
}));
|
|
});
|
|
}
|
|
|
|
const functionBuilder = new FunctionBuilder({
|
|
rootNode,
|
|
functionNodes,
|
|
nativeFunctions,
|
|
subKernelNodes
|
|
});
|
|
|
|
return functionBuilder;
|
|
}
|
|
|
|
constructor(settings) {
|
|
settings = settings || {};
|
|
this.rootNode = settings.rootNode;
|
|
this.functionNodes = settings.functionNodes || [];
|
|
this.subKernelNodes = settings.subKernelNodes || [];
|
|
this.nativeFunctions = settings.nativeFunctions || [];
|
|
this.functionMap = {};
|
|
this.nativeFunctionNames = [];
|
|
|
|
if (this.rootNode) {
|
|
this.functionMap['kernel'] = this.rootNode;
|
|
}
|
|
|
|
if (this.functionNodes) {
|
|
for (let i = 0; i < this.functionNodes.length; i++) {
|
|
this.functionMap[this.functionNodes[i].name] = this.functionNodes[i];
|
|
}
|
|
}
|
|
|
|
if (this.subKernelNodes) {
|
|
for (let i = 0; i < this.subKernelNodes.length; i++) {
|
|
this.functionMap[this.subKernelNodes[i].name] = this.subKernelNodes[i];
|
|
}
|
|
}
|
|
|
|
if (this.nativeFunctions) {
|
|
for (let i = 0; i < this.nativeFunctions.length; i++) {
|
|
this.nativeFunctionNames.push(this.nativeFunctions[i].name);
|
|
}
|
|
}
|
|
}
|
|
|
|
addFunctionNode(functionNode) {
|
|
this.functionMap[functionNode.name] = functionNode;
|
|
if (functionNode.isRootKernel) {
|
|
this.rootNode = functionNode;
|
|
}
|
|
}
|
|
|
|
traceFunctionCalls(functionName, retList, parent) {
|
|
functionName = functionName || 'kernel';
|
|
retList = retList || [];
|
|
|
|
if (this.nativeFunctionNames.indexOf(functionName) > -1) {
|
|
if (retList.indexOf(functionName) >= 0) {
|
|
} else {
|
|
retList.push(functionName);
|
|
}
|
|
return retList;
|
|
}
|
|
|
|
const functionNode = this.functionMap[functionName];
|
|
if (functionNode) {
|
|
const functionIndex = retList.indexOf(functionName);
|
|
if (functionIndex === -1) {
|
|
retList.push(functionName);
|
|
if (parent) {
|
|
functionNode.parent = parent;
|
|
}
|
|
functionNode.toString();
|
|
for (let i = 0; i < functionNode.calledFunctions.length; ++i) {
|
|
this.traceFunctionCalls(functionNode.calledFunctions[i], retList, functionNode);
|
|
}
|
|
} else {
|
|
const dependantFunctionName = retList.splice(functionIndex, 1)[0];
|
|
retList.push(dependantFunctionName);
|
|
}
|
|
}
|
|
|
|
return retList;
|
|
}
|
|
|
|
getPrototypeString(functionName) {
|
|
return this.getPrototypes(functionName).join('\n');
|
|
}
|
|
|
|
getPrototypes(functionName) {
|
|
if (this.rootNode) {
|
|
this.rootNode.toString();
|
|
}
|
|
if (functionName) {
|
|
return this.getPrototypesFromFunctionNames(this.traceFunctionCalls(functionName, []).reverse());
|
|
}
|
|
return this.getPrototypesFromFunctionNames(Object.keys(this.functionMap));
|
|
}
|
|
|
|
getStringFromFunctionNames(functionList) {
|
|
const ret = [];
|
|
for (let i = 0; i < functionList.length; ++i) {
|
|
const node = this.functionMap[functionList[i]];
|
|
if (node) {
|
|
ret.push(this.functionMap[functionList[i]].toString());
|
|
}
|
|
}
|
|
return ret.join('\n');
|
|
}
|
|
|
|
getPrototypesFromFunctionNames(functionList) {
|
|
const ret = [];
|
|
for (let i = 0; i < functionList.length; ++i) {
|
|
const functionName = functionList[i];
|
|
const functionIndex = this.nativeFunctionNames.indexOf(functionName);
|
|
if (functionIndex > -1) {
|
|
ret.push(this.nativeFunctions[functionIndex].source);
|
|
continue;
|
|
}
|
|
const node = this.functionMap[functionName];
|
|
if (node) {
|
|
ret.push(node.toString());
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
toJSON() {
|
|
return this.traceFunctionCalls(this.rootNode.name).reverse().map(name => {
|
|
if (this.nativeFunctions[name]) {
|
|
return {
|
|
name,
|
|
source: this.nativeFunctions[name]
|
|
};
|
|
} else if (this.functionMap[name]) {
|
|
return this.functionMap[name].toJSON();
|
|
} else {
|
|
throw new Error(`function ${ name } not found`);
|
|
}
|
|
});
|
|
}
|
|
|
|
fromJSON(jsonFunctionNodes, FunctionNode) {
|
|
this.functionMap = {};
|
|
for (let i = 0; i < jsonFunctionNodes.length; i++) {
|
|
const jsonFunctionNode = jsonFunctionNodes[i];
|
|
this.functionMap[jsonFunctionNode.settings.name] = new FunctionNode(jsonFunctionNode.ast, jsonFunctionNode.settings);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
getString(functionName) {
|
|
if (functionName) {
|
|
return this.getStringFromFunctionNames(this.traceFunctionCalls(functionName).reverse());
|
|
}
|
|
return this.getStringFromFunctionNames(Object.keys(this.functionMap));
|
|
}
|
|
|
|
lookupReturnType(functionName) {
|
|
const node = this.functionMap[functionName];
|
|
if (node && node.returnType) {
|
|
return node.returnType;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
FunctionBuilder
|
|
};
|
|
},{}],9:[function(require,module,exports){
|
|
const {
|
|
utils
|
|
} = require('../utils');
|
|
const acorn = require('acorn');
|
|
|
|
class FunctionNode {
|
|
constructor(source, settings) {
|
|
if (!source) {
|
|
throw new Error('source parameter is missing');
|
|
}
|
|
settings = settings || {};
|
|
|
|
this.source = source;
|
|
this.name = typeof source === 'string' ? settings.isRootKernel ?
|
|
'kernel' :
|
|
(settings.name || utils.getFunctionNameFromString(source)) : null;
|
|
this.calledFunctions = [];
|
|
this.calledFunctionsArguments = {};
|
|
this.constants = {};
|
|
this.constantTypes = {};
|
|
this.isRootKernel = false;
|
|
this.isSubKernel = false;
|
|
this.parent = null;
|
|
this.debug = null;
|
|
this.declarations = {};
|
|
this.states = [];
|
|
this.lookupReturnType = null;
|
|
this.onNestedFunction = null;
|
|
this.loopMaxIterations = null;
|
|
this.argumentNames = (typeof this.source === 'string' ? utils.getArgumentNamesFromString(this.source) : null);
|
|
this.argumentTypes = [];
|
|
this.argumentSizes = [];
|
|
this.returnType = null;
|
|
this.output = [];
|
|
this.plugins = null;
|
|
|
|
if (settings) {
|
|
for (const p in settings) {
|
|
if (!settings.hasOwnProperty(p)) continue;
|
|
if (!this.hasOwnProperty(p)) continue;
|
|
this[p] = settings[p];
|
|
}
|
|
}
|
|
|
|
if (!this.returnType) {
|
|
this.returnType = 'Number';
|
|
}
|
|
|
|
this.validate();
|
|
this._string = null;
|
|
this._internalVariableNames = {};
|
|
}
|
|
|
|
validate() {
|
|
if (typeof this.source !== 'string') {
|
|
throw new Error('this.source not a string');
|
|
}
|
|
|
|
if (!utils.isFunctionString(this.source)) {
|
|
throw new Error('this.source not a function string');
|
|
}
|
|
|
|
if (!this.name) {
|
|
throw new Error('this.name could not be set');
|
|
}
|
|
|
|
if (this.argumentTypes.length > 0 && this.argumentTypes.length !== this.argumentNames.length) {
|
|
throw new Error(`argumentTypes count of ${ this.argumentTypes.length } exceeds ${ this.argumentNames.length }`);
|
|
}
|
|
|
|
if (this.output.length < 1) {
|
|
throw new Error('this.output is not big enough');
|
|
}
|
|
}
|
|
|
|
isIdentifierConstant(name) {
|
|
if (!this.constants) return false;
|
|
return this.constants.hasOwnProperty(name);
|
|
}
|
|
|
|
isInput(argumentName) {
|
|
return this.argumentTypes[this.argumentNames.indexOf(argumentName)] === 'Input';
|
|
}
|
|
|
|
pushState(state) {
|
|
this.states.push(state);
|
|
}
|
|
|
|
popState(state) {
|
|
if (this.state !== state) {
|
|
throw new Error(`Cannot popState ${ state } when in ${ this.state }`);
|
|
}
|
|
this.states.pop();
|
|
}
|
|
|
|
isState(state) {
|
|
return this.state === state;
|
|
}
|
|
|
|
get state() {
|
|
return this.states[this.states.length - 1];
|
|
}
|
|
|
|
astMemberExpressionUnroll(ast) {
|
|
if (ast.type === 'Identifier') {
|
|
return ast.name;
|
|
} else if (ast.type === 'ThisExpression') {
|
|
return 'this';
|
|
}
|
|
|
|
if (ast.type === 'MemberExpression') {
|
|
if (ast.object && ast.property) {
|
|
if (ast.object.hasOwnProperty('name') && ast.object.name[0] === '_') {
|
|
return this.astMemberExpressionUnroll(ast.property);
|
|
}
|
|
|
|
return (
|
|
this.astMemberExpressionUnroll(ast.object) +
|
|
'.' +
|
|
this.astMemberExpressionUnroll(ast.property)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (ast.hasOwnProperty('expressions')) {
|
|
const firstExpression = ast.expressions[0];
|
|
if (firstExpression.type === 'Literal' && firstExpression.value === 0 && ast.expressions.length === 2) {
|
|
return this.astMemberExpressionUnroll(ast.expressions[1]);
|
|
}
|
|
}
|
|
|
|
throw this.astErrorOutput('Unknown astMemberExpressionUnroll', ast);
|
|
}
|
|
|
|
getJsAST(inParser) {
|
|
if (typeof this.source === 'object') {
|
|
return this.ast = this.source;
|
|
}
|
|
|
|
inParser = inParser || acorn;
|
|
if (inParser === null) {
|
|
throw 'Missing JS to AST parser';
|
|
}
|
|
|
|
const ast = Object.freeze(inParser.parse(`const parser_${ this.name } = ${ this.source };`, {
|
|
locations: true
|
|
}));
|
|
const functionAST = ast.body[0].declarations[0].init;
|
|
if (!ast) {
|
|
throw new Error('Failed to parse JS code');
|
|
}
|
|
|
|
return this.ast = functionAST;
|
|
}
|
|
|
|
getVariableType(name) {
|
|
let type = null;
|
|
const argumentIndex = this.argumentNames.indexOf(name);
|
|
if (argumentIndex === -1) {
|
|
if (this.declarations[name]) {
|
|
return this.declarations[name].type;
|
|
}
|
|
} else {
|
|
const argumentType = this.argumentTypes[argumentIndex];
|
|
if (argumentType) {
|
|
type = argumentType;
|
|
} else if (this.parent) {
|
|
const calledFunctionArguments = this.parent.calledFunctionsArguments[this.name];
|
|
for (let i = 0; i < calledFunctionArguments.length; i++) {
|
|
const calledFunctionArgument = calledFunctionArguments[i];
|
|
if (calledFunctionArgument[argumentIndex] !== null) {
|
|
type = calledFunctionArgument[argumentIndex].type;
|
|
this.argumentTypes[argumentIndex] = type;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!type) {
|
|
}
|
|
return type;
|
|
}
|
|
|
|
getConstantType(constantName) {
|
|
if (this.constantTypes[constantName]) {
|
|
const type = this.constantTypes[constantName];
|
|
if (type === 'Float') {
|
|
return 'Number';
|
|
} else {
|
|
return type;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
getUserArgumentName(name) {
|
|
const argumentIndex = this.argumentNames.indexOf(name);
|
|
if (argumentIndex === -1) return null;
|
|
if (!this.parent || this.isRootKernel) return null;
|
|
const calledFunctionArguments = this.parent.calledFunctionsArguments[this.name];
|
|
for (let i = 0; i < calledFunctionArguments.length; i++) {
|
|
const calledFunctionArgument = calledFunctionArguments[i];
|
|
const argument = calledFunctionArgument[argumentIndex];
|
|
if (argument && argument.type !== 'Integer' && argument.type !== 'LiteralInteger' && argument.type !== 'Number') {
|
|
return argument.name;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
toString() {
|
|
if (this._string) return this._string;
|
|
return this._string = this.astGeneric(this.getJsAST(), []).join('').trim();
|
|
}
|
|
|
|
toJSON() {
|
|
const settings = {
|
|
source: this.source,
|
|
name: this.name,
|
|
constants: this.constants,
|
|
constantTypes: this.constantTypes,
|
|
isRootKernel: this.isRootKernel,
|
|
isSubKernel: this.isSubKernel,
|
|
debug: this.debug,
|
|
output: this.output,
|
|
loopMaxIterations: this.loopMaxIterations,
|
|
argumentNames: this.argumentNames,
|
|
argumentTypes: this.argumentTypes,
|
|
argumentSizes: this.argumentSizes,
|
|
returnType: this.returnType
|
|
};
|
|
|
|
return {
|
|
ast: this.ast,
|
|
settings
|
|
};
|
|
}
|
|
|
|
getType(ast) {
|
|
if (Array.isArray(ast)) {
|
|
return this.getType(ast[ast.length - 1]);
|
|
}
|
|
switch (ast.type) {
|
|
case 'BlockStatement':
|
|
return this.getType(ast.body);
|
|
case 'ArrayExpression':
|
|
return `Array(${ ast.elements.length })`;
|
|
case 'Literal':
|
|
if (Number.isInteger(ast.value)) {
|
|
return 'LiteralInteger';
|
|
} else {
|
|
return 'Number';
|
|
}
|
|
case 'CallExpression':
|
|
if (this.isAstMathFunction(ast)) {
|
|
return 'Number';
|
|
}
|
|
return ast.callee && ast.callee.name && this.lookupReturnType ? this.lookupReturnType(ast.callee.name) : null;
|
|
case 'BinaryExpression':
|
|
if (ast.operator === '%') {
|
|
return 'Number';
|
|
} else if (ast.operator === '>' || ast.operator === '<') {
|
|
return 'Boolean';
|
|
}
|
|
const type = this.getType(ast.left);
|
|
return typeLookupMap[type] || type;
|
|
case 'UpdateExpression':
|
|
return this.getType(ast.argument);
|
|
case 'UnaryExpression':
|
|
return this.getType(ast.argument);
|
|
case 'VariableDeclaration':
|
|
return this.getType(ast.declarations[0]);
|
|
case 'VariableDeclarator':
|
|
return this.getType(ast.id);
|
|
case 'Identifier':
|
|
if (this.isAstVariable(ast)) {
|
|
const signature = this.getVariableSignature(ast);
|
|
if (signature === 'value') {
|
|
if (this.argumentNames.indexOf(ast.name) > -1) {
|
|
return this.getVariableType(ast.name);
|
|
} else if (this.declarations[ast.name]) {
|
|
return this.declarations[ast.name].type;
|
|
}
|
|
}
|
|
}
|
|
if (ast.name === 'Infinity') {
|
|
return 'Integer';
|
|
}
|
|
return null;
|
|
case 'ReturnStatement':
|
|
return this.getType(ast.argument);
|
|
case 'MemberExpression':
|
|
if (this.isAstMathFunction(ast)) {
|
|
switch (ast.property.name) {
|
|
case 'ceil':
|
|
return 'Integer';
|
|
case 'floor':
|
|
return 'Integer';
|
|
case 'round':
|
|
return 'Integer';
|
|
}
|
|
return 'Number';
|
|
}
|
|
if (this.isAstVariable(ast)) {
|
|
const variableSignature = this.getVariableSignature(ast);
|
|
switch (variableSignature) {
|
|
case 'value[]':
|
|
return typeLookupMap[this.getVariableType(ast.object.name)];
|
|
case 'value[][]':
|
|
return typeLookupMap[this.getVariableType(ast.object.object.name)];
|
|
case 'value[][][]':
|
|
return typeLookupMap[this.getVariableType(ast.object.object.object.name)];
|
|
case 'this.thread.value':
|
|
return 'Integer';
|
|
case 'this.output.value':
|
|
return 'Integer';
|
|
case 'this.constants.value':
|
|
return this.getConstantType(ast.property.name);
|
|
case 'this.constants.value[]':
|
|
return typeLookupMap[this.getConstantType(ast.object.property.name)];
|
|
case 'this.constants.value[][]':
|
|
return typeLookupMap[this.getConstantType(ast.object.object.property.name)];
|
|
case 'this.constants.value[][][]':
|
|
return typeLookupMap[this.getConstantType(ast.object.object.object.property.name)];
|
|
case 'fn()[]':
|
|
return typeLookupMap[this.getType(ast.object)];
|
|
case 'fn()[][]':
|
|
return typeLookupMap[this.getType(ast.object)];
|
|
case 'fn()[][][]':
|
|
return typeLookupMap[this.getType(ast.object)];
|
|
case 'value.value':
|
|
if (this.isAstMathVariable(ast)) {
|
|
return 'Number';
|
|
}
|
|
switch (ast.property.name) {
|
|
case 'r':
|
|
return typeLookupMap[this.getVariableType(ast.object.name)];
|
|
case 'g':
|
|
return typeLookupMap[this.getVariableType(ast.object.name)];
|
|
case 'b':
|
|
return typeLookupMap[this.getVariableType(ast.object.name)];
|
|
case 'a':
|
|
return typeLookupMap[this.getVariableType(ast.object.name)];
|
|
}
|
|
}
|
|
throw this.astErrorOutput('Unhandled getType MemberExpression', ast);
|
|
}
|
|
throw this.astErrorOutput('Unhandled getType MemberExpression', ast);
|
|
case 'FunctionDeclaration':
|
|
return this.getType(ast.body);
|
|
case 'ConditionalExpression':
|
|
return this.getType(ast.consequent);
|
|
default:
|
|
throw this.astErrorOutput(`Unhandled getType Type "${ ast.type }"`, ast);
|
|
}
|
|
}
|
|
|
|
isAstMathVariable(ast) {
|
|
const mathProperties = [
|
|
'E',
|
|
'PI',
|
|
'SQRT2',
|
|
'SQRT1_2',
|
|
'LN2',
|
|
'LN10',
|
|
'LOG2E',
|
|
'LOG10E',
|
|
];
|
|
return ast.type === 'MemberExpression' &&
|
|
ast.object && ast.object.type === 'Identifier' &&
|
|
ast.object.name === 'Math' &&
|
|
ast.property &&
|
|
ast.property.type === 'Identifier' &&
|
|
mathProperties.indexOf(ast.property.name) > -1;
|
|
}
|
|
|
|
isAstMathFunction(ast) {
|
|
const mathFunctions = [
|
|
'abs',
|
|
'acos',
|
|
'asin',
|
|
'atan',
|
|
'atan2',
|
|
'ceil',
|
|
'cos',
|
|
'exp',
|
|
'floor',
|
|
'log',
|
|
'log2',
|
|
'max',
|
|
'min',
|
|
'pow',
|
|
'random',
|
|
'round',
|
|
'sign',
|
|
'sin',
|
|
'sqrt',
|
|
'tan',
|
|
];
|
|
return ast.type === 'CallExpression' &&
|
|
ast.callee &&
|
|
ast.callee.type === 'MemberExpression' &&
|
|
ast.callee.object &&
|
|
ast.callee.object.type === 'Identifier' &&
|
|
ast.callee.object.name === 'Math' &&
|
|
ast.callee.property &&
|
|
ast.callee.property.type === 'Identifier' &&
|
|
mathFunctions.indexOf(ast.callee.property.name) > -1;
|
|
}
|
|
|
|
isAstVariable(ast) {
|
|
return ast.type === 'Identifier' || ast.type === 'MemberExpression';
|
|
}
|
|
|
|
isSafe(ast) {
|
|
return this.isSafeDependencies(this.getDependencies(ast));
|
|
}
|
|
|
|
isSafeDependencies(dependencies) {
|
|
return dependencies && dependencies.every ? dependencies.every(dependency => dependency.isSafe) : true;
|
|
}
|
|
|
|
getDependencies(ast, dependencies, isNotSafe) {
|
|
if (!dependencies) {
|
|
dependencies = [];
|
|
}
|
|
if (!ast) return null;
|
|
if (Array.isArray(ast)) {
|
|
for (let i = 0; i < ast.length; i++) {
|
|
this.getDependencies(ast[i], dependencies, isNotSafe);
|
|
}
|
|
return dependencies;
|
|
}
|
|
switch (ast.type) {
|
|
case 'Literal':
|
|
dependencies.push({
|
|
origin: 'literal',
|
|
value: ast.value,
|
|
isSafe: isNotSafe === true ? false : ast.value > -Infinity && ast.value < Infinity && !isNaN(ast.value)
|
|
});
|
|
break;
|
|
case 'VariableDeclarator':
|
|
return this.getDependencies(ast.init, dependencies, isNotSafe);
|
|
case 'Identifier':
|
|
if (this.declarations[ast.name]) {
|
|
dependencies.push({
|
|
name: ast.name,
|
|
origin: 'declaration',
|
|
isSafe: isNotSafe ? false : this.isSafeDependencies(this.declarations[ast.name].dependencies),
|
|
});
|
|
} else if (this.argumentNames.indexOf(ast.name) > -1) {
|
|
dependencies.push({
|
|
name: ast.name,
|
|
origin: 'argument',
|
|
isSafe: false,
|
|
});
|
|
}
|
|
break;
|
|
case 'FunctionDeclaration':
|
|
return this.getDependencies(ast.body.body[ast.body.body.length - 1], dependencies, isNotSafe);
|
|
case 'ReturnStatement':
|
|
return this.getDependencies(ast.argument, dependencies);
|
|
case 'BinaryExpression':
|
|
isNotSafe = (ast.operator === '/' || ast.operator === '*');
|
|
this.getDependencies(ast.left, dependencies, isNotSafe);
|
|
this.getDependencies(ast.right, dependencies, isNotSafe);
|
|
return dependencies;
|
|
case 'UpdateExpression':
|
|
return this.getDependencies(ast.argument, dependencies, isNotSafe);
|
|
case 'VariableDeclaration':
|
|
return this.getDependencies(ast.declarations, dependencies, isNotSafe);
|
|
case 'ArrayExpression':
|
|
dependencies.push({
|
|
origin: 'declaration',
|
|
isSafe: true,
|
|
});
|
|
return dependencies;
|
|
case 'CallExpression':
|
|
dependencies.push({
|
|
origin: 'function',
|
|
isSafe: true,
|
|
});
|
|
return dependencies;
|
|
case 'MemberExpression':
|
|
const details = this.getMemberExpressionDetails(ast);
|
|
if (details) {
|
|
return details.type;
|
|
}
|
|
default:
|
|
throw this.astErrorOutput(`Unhandled type ${ ast.type } in getAllVariables`, ast);
|
|
}
|
|
return dependencies;
|
|
}
|
|
|
|
getVariableSignature(ast) {
|
|
if (!this.isAstVariable(ast)) {
|
|
throw new Error(`ast of type "${ ast.type }" is not a variable signature`);
|
|
}
|
|
if (ast.type === 'Identifier') {
|
|
return 'value';
|
|
}
|
|
const signature = [];
|
|
while (true) {
|
|
if (!ast) break;
|
|
if (ast.computed) {
|
|
signature.push('[]');
|
|
} else if (ast.type === 'ThisExpression') {
|
|
signature.unshift('this');
|
|
} else if (ast.property && ast.property.name) {
|
|
if (
|
|
ast.property.name === 'x' ||
|
|
ast.property.name === 'y' ||
|
|
ast.property.name === 'z'
|
|
) {
|
|
signature.unshift('.value');
|
|
} else if (
|
|
ast.property.name === 'constants' ||
|
|
ast.property.name === 'thread' ||
|
|
ast.property.name === 'output'
|
|
) {
|
|
signature.unshift('.' + ast.property.name);
|
|
} else {
|
|
signature.unshift('.value');
|
|
}
|
|
} else if (ast.name) {
|
|
signature.unshift('value');
|
|
} else if (ast.callee && ast.callee.name) {
|
|
signature.unshift('fn()');
|
|
} else {
|
|
signature.unshift('unknown');
|
|
}
|
|
ast = ast.object;
|
|
}
|
|
|
|
const signatureString = signature.join('');
|
|
const allowedExpressions = [
|
|
'value',
|
|
'value[]',
|
|
'value[][]',
|
|
'value[][][]',
|
|
'value.value',
|
|
'this.thread.value',
|
|
'this.output.value',
|
|
'this.constants.value',
|
|
'this.constants.value[]',
|
|
'this.constants.value[][]',
|
|
'this.constants.value[][][]',
|
|
'fn()[]',
|
|
'fn()[][]',
|
|
'fn()[][][]',
|
|
];
|
|
if (allowedExpressions.indexOf(signatureString) > -1) {
|
|
return signatureString;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
build() {
|
|
return this.toString().length > 0;
|
|
}
|
|
|
|
astGeneric(ast, retArr) {
|
|
if (ast === null) {
|
|
throw this.astErrorOutput('NULL ast', ast);
|
|
} else {
|
|
if (Array.isArray(ast)) {
|
|
for (let i = 0; i < ast.length; i++) {
|
|
this.astGeneric(ast[i], retArr);
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
switch (ast.type) {
|
|
case 'FunctionDeclaration':
|
|
return this.astFunctionDeclaration(ast, retArr);
|
|
case 'FunctionExpression':
|
|
return this.astFunctionExpression(ast, retArr);
|
|
case 'ReturnStatement':
|
|
return this.astReturnStatement(ast, retArr);
|
|
case 'Literal':
|
|
return this.astLiteral(ast, retArr);
|
|
case 'BinaryExpression':
|
|
return this.astBinaryExpression(ast, retArr);
|
|
case 'Identifier':
|
|
return this.astIdentifierExpression(ast, retArr);
|
|
case 'AssignmentExpression':
|
|
return this.astAssignmentExpression(ast, retArr);
|
|
case 'ExpressionStatement':
|
|
return this.astExpressionStatement(ast, retArr);
|
|
case 'EmptyStatement':
|
|
return this.astEmptyStatement(ast, retArr);
|
|
case 'BlockStatement':
|
|
return this.astBlockStatement(ast, retArr);
|
|
case 'IfStatement':
|
|
return this.astIfStatement(ast, retArr);
|
|
case 'BreakStatement':
|
|
return this.astBreakStatement(ast, retArr);
|
|
case 'ContinueStatement':
|
|
return this.astContinueStatement(ast, retArr);
|
|
case 'ForStatement':
|
|
return this.astForStatement(ast, retArr);
|
|
case 'WhileStatement':
|
|
return this.astWhileStatement(ast, retArr);
|
|
case 'DoWhileStatement':
|
|
return this.astDoWhileStatement(ast, retArr);
|
|
case 'VariableDeclaration':
|
|
return this.astVariableDeclaration(ast, retArr);
|
|
case 'VariableDeclarator':
|
|
return this.astVariableDeclarator(ast, retArr);
|
|
case 'ThisExpression':
|
|
return this.astThisExpression(ast, retArr);
|
|
case 'SequenceExpression':
|
|
return this.astSequenceExpression(ast, retArr);
|
|
case 'UnaryExpression':
|
|
return this.astUnaryExpression(ast, retArr);
|
|
case 'UpdateExpression':
|
|
return this.astUpdateExpression(ast, retArr);
|
|
case 'LogicalExpression':
|
|
return this.astLogicalExpression(ast, retArr);
|
|
case 'MemberExpression':
|
|
return this.astMemberExpression(ast, retArr);
|
|
case 'CallExpression':
|
|
return this.astCallExpression(ast, retArr);
|
|
case 'ArrayExpression':
|
|
return this.astArrayExpression(ast, retArr);
|
|
case 'DebuggerStatement':
|
|
return this.astDebuggerStatement(ast, retArr);
|
|
case 'ConditionalExpression':
|
|
return this.astConditionalExpression(ast, retArr);
|
|
}
|
|
|
|
throw this.astErrorOutput('Unknown ast type : ' + ast.type, ast);
|
|
}
|
|
}
|
|
astErrorOutput(error, ast) {
|
|
if (typeof this.source !== 'string') {
|
|
return new Error(error);
|
|
}
|
|
|
|
const debugString = utils.getAstString(this.source, ast);
|
|
const leadingSource = this.source.substr(ast.start);
|
|
const splitLines = leadingSource.split(/\n/);
|
|
const lineBefore = splitLines.length > 0 ? splitLines[splitLines.length - 1] : 0;
|
|
return new Error(`${error} on line ${ splitLines.length }, position ${ lineBefore.length }:\n ${ debugString }`);
|
|
}
|
|
|
|
astDebuggerStatement(arrNode, retArr) {
|
|
return retArr;
|
|
}
|
|
|
|
astConditionalExpression(ast, retArr) {
|
|
if (ast.type !== 'ConditionalExpression') {
|
|
throw this.astErrorOutput('Not a conditional expression', ast);
|
|
}
|
|
retArr.push('(');
|
|
this.astGeneric(ast.test, retArr);
|
|
retArr.push('?');
|
|
this.astGeneric(ast.consequent, retArr);
|
|
retArr.push(':');
|
|
this.astGeneric(ast.alternate, retArr);
|
|
retArr.push(')');
|
|
return retArr;
|
|
}
|
|
astFunctionDeclaration(ast, retArr) {
|
|
if (this.onNestedFunction) {
|
|
let returnType = this.getType(ast);
|
|
if (returnType === 'LiteralInteger') {
|
|
returnType = 'Number';
|
|
}
|
|
this.onNestedFunction(utils.getAstString(this.source, ast), returnType);
|
|
}
|
|
return retArr;
|
|
}
|
|
astFunctionExpression(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
astReturnStatement(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
astLiteral(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
astBinaryExpression(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
astIdentifierExpression(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
astAssignmentExpression(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
astExpressionStatement(esNode, retArr) {
|
|
this.astGeneric(esNode.expression, retArr);
|
|
retArr.push(';');
|
|
return retArr;
|
|
}
|
|
astEmptyStatement(eNode, retArr) {
|
|
return retArr;
|
|
}
|
|
astBlockStatement(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
astIfStatement(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
astBreakStatement(brNode, retArr) {
|
|
retArr.push('break;');
|
|
return retArr;
|
|
}
|
|
astContinueStatement(crNode, retArr) {
|
|
retArr.push('continue;\n');
|
|
return retArr;
|
|
}
|
|
astForStatement(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
astWhileStatement(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
astDoWhileStatement(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
astVariableDeclaration(varDecNode, retArr) {
|
|
const declarations = varDecNode.declarations;
|
|
if (!declarations || !declarations[0] || !declarations[0].init) {
|
|
throw this.astErrorOutput('Unexpected expression', varDecNode);
|
|
}
|
|
const result = [];
|
|
const firstDeclaration = declarations[0];
|
|
const init = firstDeclaration.init;
|
|
let type = this.isState('in-for-loop-init') ? 'Integer' : this.getType(init);
|
|
if (type === 'LiteralInteger') {
|
|
type = 'Number';
|
|
}
|
|
const markupType = typeMap[type];
|
|
if (!markupType) {
|
|
throw this.astErrorOutput(`Markup type ${ markupType } not handled`, varDecNode);
|
|
}
|
|
let dependencies = this.getDependencies(firstDeclaration.init);
|
|
this.declarations[firstDeclaration.id.name] = Object.freeze({
|
|
type,
|
|
dependencies,
|
|
isSafe: dependencies.every(dependency => dependency.isSafe)
|
|
});
|
|
const initResult = [`${type} user_${firstDeclaration.id.name}=`];
|
|
this.astGeneric(init, initResult);
|
|
result.push(initResult.join(''));
|
|
|
|
for (let i = 1; i < declarations.length; i++) {
|
|
const declaration = declarations[i];
|
|
dependencies = this.getDependencies(declaration);
|
|
this.declarations[declaration.id.name] = Object.freeze({
|
|
type,
|
|
dependencies,
|
|
isSafe: false
|
|
});
|
|
this.astGeneric(declaration, result);
|
|
}
|
|
|
|
retArr.push(retArr, result.join(','));
|
|
retArr.push(';');
|
|
return retArr;
|
|
}
|
|
astVariableDeclarator(iVarDecNode, retArr) {
|
|
this.astGeneric(iVarDecNode.id, retArr);
|
|
if (iVarDecNode.init !== null) {
|
|
retArr.push('=');
|
|
this.astGeneric(iVarDecNode.init, retArr);
|
|
}
|
|
return retArr;
|
|
}
|
|
astThisExpression(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
astSequenceExpression(sNode, retArr) {
|
|
for (let i = 0; i < sNode.expressions.length; i++) {
|
|
if (i > 0) {
|
|
retArr.push(',');
|
|
}
|
|
this.astGeneric(sNode.expressions, retArr);
|
|
}
|
|
return retArr;
|
|
}
|
|
astUnaryExpression(uNode, retArr) {
|
|
if (uNode.prefix) {
|
|
retArr.push(uNode.operator);
|
|
this.astGeneric(uNode.argument, retArr);
|
|
} else {
|
|
this.astGeneric(uNode.argument, retArr);
|
|
retArr.push(uNode.operator);
|
|
}
|
|
|
|
return retArr;
|
|
}
|
|
astUpdateExpression(uNode, retArr) {
|
|
if (uNode.prefix) {
|
|
retArr.push(uNode.operator);
|
|
this.astGeneric(uNode.argument, retArr);
|
|
} else {
|
|
this.astGeneric(uNode.argument, retArr);
|
|
retArr.push(uNode.operator);
|
|
}
|
|
|
|
return retArr;
|
|
}
|
|
astLogicalExpression(logNode, retArr) {
|
|
retArr.push('(');
|
|
this.astGeneric(logNode.left, retArr);
|
|
retArr.push(logNode.operator);
|
|
this.astGeneric(logNode.right, retArr);
|
|
retArr.push(')');
|
|
return retArr;
|
|
}
|
|
astMemberExpression(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
astCallExpression(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
astArrayExpression(ast, retArr) {
|
|
return retArr;
|
|
}
|
|
|
|
getMemberExpressionDetails(ast) {
|
|
if (ast.type !== 'MemberExpression') {
|
|
throw this.astErrorOutput(`Expression ${ ast.type } not a MemberExpression`, ast);
|
|
}
|
|
let name = null;
|
|
let type = null;
|
|
const variableSignature = this.getVariableSignature(ast);
|
|
switch (variableSignature) {
|
|
case 'value':
|
|
return null;
|
|
case 'this.thread.value':
|
|
case 'this.output.value':
|
|
return {
|
|
signature: variableSignature,
|
|
type: 'Integer',
|
|
name: ast.property.name
|
|
};
|
|
case 'value[]':
|
|
if (typeof ast.object.name !== 'string') {
|
|
throw this.astErrorOutput('Unexpected expression', ast);
|
|
}
|
|
name = ast.object.name;
|
|
return {
|
|
name,
|
|
origin: 'user',
|
|
signature: variableSignature,
|
|
type: this.getVariableType(name),
|
|
xProperty: ast.property
|
|
};
|
|
case 'value[][]':
|
|
if (typeof ast.object.object.name !== 'string') {
|
|
throw this.astErrorOutput('Unexpected expression', ast);
|
|
}
|
|
name = ast.object.object.name;
|
|
return {
|
|
name,
|
|
origin: 'user',
|
|
signature: variableSignature,
|
|
type: this.getVariableType(name),
|
|
yProperty: ast.object.property,
|
|
xProperty: ast.property,
|
|
};
|
|
case 'value[][][]':
|
|
if (typeof ast.object.object.object.name !== 'string') {
|
|
throw this.astErrorOutput('Unexpected expression', ast);
|
|
}
|
|
name = ast.object.object.object.name;
|
|
return {
|
|
name,
|
|
origin: 'user',
|
|
signature: variableSignature,
|
|
type: this.getVariableType(name),
|
|
zProperty: ast.object.object.property,
|
|
yProperty: ast.object.property,
|
|
xProperty: ast.property,
|
|
};
|
|
case 'value.value':
|
|
if (typeof ast.property.name !== 'string') {
|
|
throw this.astErrorOutput('Unexpected expression', ast);
|
|
}
|
|
if (this.isAstMathVariable(ast)) {
|
|
name = ast.property.name;
|
|
return {
|
|
name,
|
|
origin: 'Math',
|
|
type: 'Number',
|
|
signature: variableSignature,
|
|
};
|
|
}
|
|
switch (ast.property.name) {
|
|
case 'r':
|
|
case 'g':
|
|
case 'b':
|
|
case 'a':
|
|
name = ast.object.name;
|
|
return {
|
|
name,
|
|
property: ast.property.name,
|
|
origin: 'user',
|
|
signature: variableSignature,
|
|
type: 'Number'
|
|
};
|
|
default:
|
|
throw this.astErrorOutput('Unexpected expression', ast);
|
|
}
|
|
case 'this.constants.value':
|
|
if (typeof ast.property.name !== 'string') {
|
|
throw this.astErrorOutput('Unexpected expression', ast);
|
|
}
|
|
name = ast.property.name;
|
|
type = this.getConstantType(name);
|
|
if (!type) {
|
|
throw this.astErrorOutput('Constant has no type', ast);
|
|
}
|
|
return {
|
|
name,
|
|
type,
|
|
origin: 'constants',
|
|
signature: variableSignature,
|
|
};
|
|
case 'this.constants.value[]':
|
|
if (typeof ast.object.property.name !== 'string') {
|
|
throw this.astErrorOutput('Unexpected expression', ast);
|
|
}
|
|
name = ast.object.property.name;
|
|
type = this.getConstantType(name);
|
|
if (!type) {
|
|
throw this.astErrorOutput('Constant has no type', ast);
|
|
}
|
|
return {
|
|
name,
|
|
type,
|
|
origin: 'constants',
|
|
signature: variableSignature,
|
|
xProperty: ast.property,
|
|
};
|
|
case 'this.constants.value[][]':
|
|
{
|
|
if (typeof ast.object.object.property.name !== 'string') {
|
|
throw this.astErrorOutput('Unexpected expression', ast);
|
|
}
|
|
name = ast.object.object.property.name;
|
|
type = this.getConstantType(name);
|
|
if (!type) {
|
|
throw this.astErrorOutput('Constant has no type', ast);
|
|
}
|
|
return {
|
|
name,
|
|
type,
|
|
origin: 'constants',
|
|
signature: variableSignature,
|
|
yProperty: ast.object.property,
|
|
xProperty: ast.property,
|
|
};
|
|
}
|
|
case 'this.constants.value[][][]':
|
|
{
|
|
if (typeof ast.object.object.object.property.name !== 'string') {
|
|
throw this.astErrorOutput('Unexpected expression', ast);
|
|
}
|
|
name = ast.object.object.object.property.name;
|
|
type = this.getConstantType(name);
|
|
if (!type) {
|
|
throw this.astErrorOutput('Constant has no type', ast);
|
|
}
|
|
return {
|
|
name,
|
|
type,
|
|
origin: 'constants',
|
|
signature: variableSignature,
|
|
zProperty: ast.object.object.property,
|
|
yProperty: ast.object.property,
|
|
xProperty: ast.property,
|
|
};
|
|
}
|
|
case 'fn()[]':
|
|
return {
|
|
signature: variableSignature,
|
|
property: ast.property
|
|
};
|
|
default:
|
|
throw this.astErrorOutput('Unexpected expression', ast);
|
|
}
|
|
}
|
|
|
|
getInternalVariableName(name) {
|
|
if (!this._internalVariableNames.hasOwnProperty(name)) {
|
|
this._internalVariableNames[name] = 0;
|
|
}
|
|
this._internalVariableNames[name]++;
|
|
if (this._internalVariableNames[name] === 1) {
|
|
return name;
|
|
}
|
|
return name + this._internalVariableNames[name];
|
|
}
|
|
}
|
|
|
|
const typeLookupMap = {
|
|
'Array': 'Number',
|
|
'Array(2)': 'Number',
|
|
'Array(3)': 'Number',
|
|
'Array(4)': 'Number',
|
|
'Array2D': 'Number',
|
|
'Array3D': 'Number',
|
|
'HTMLImage': 'Array(4)',
|
|
'HTMLImageArray': 'Array(4)',
|
|
'NumberTexture': 'Number',
|
|
'ArrayTexture(4)': 'Array(4)',
|
|
};
|
|
|
|
module.exports = {
|
|
FunctionNode
|
|
};
|
|
},{"../utils":29,"acorn":1}],10:[function(require,module,exports){
|
|
const {
|
|
Kernel
|
|
} = require('./kernel');
|
|
|
|
class GLKernel extends Kernel {
|
|
static get mode() {
|
|
return 'gpu';
|
|
}
|
|
|
|
static getIsFloatRead() {
|
|
function kernelFunction() {
|
|
return 1;
|
|
}
|
|
const kernel = new this(kernelFunction.toString(), {
|
|
context: this.testContext,
|
|
canvas: this.testCanvas,
|
|
skipValidate: true,
|
|
output: [2],
|
|
floatTextures: true,
|
|
floatOutput: true,
|
|
floatOutputForce: true
|
|
});
|
|
const result = kernel.run();
|
|
kernel.destroy(true);
|
|
return result[0] === 1;
|
|
}
|
|
|
|
static getIsIntegerDivisionAccurate() {
|
|
function kernelFunction(v1, v2) {
|
|
return v1[this.thread.x] / v2[this.thread.x];
|
|
}
|
|
const kernel = new this(kernelFunction.toString(), {
|
|
context: this.testContext,
|
|
canvas: this.testCanvas,
|
|
skipValidate: true,
|
|
output: [2]
|
|
});
|
|
const result = kernel.run([6, 6030401], [3, 3991]);
|
|
kernel.destroy(true);
|
|
return result[0] === 2 && result[1] === 1511;
|
|
}
|
|
|
|
static get testCanvas() {
|
|
throw new Error(`"testCanvas" not defined on ${ this.name }`);
|
|
}
|
|
|
|
static get testContext() {
|
|
throw new Error(`"testContext" not defined on ${ this.name }`);
|
|
}
|
|
|
|
static get features() {
|
|
throw new Error(`"features" not defined on ${ this.name }`);
|
|
}
|
|
|
|
static setupFeatureChecks() {
|
|
throw new Error(`"setupFeatureChecks" not defined on ${ this.name }`);
|
|
}
|
|
|
|
setFixIntegerDivisionAccuracy(fix) {
|
|
this.fixIntegerDivisionAccuracy = fix;
|
|
return this;
|
|
}
|
|
|
|
setFloatOutput(flag) {
|
|
this.floatOutput = flag;
|
|
return this;
|
|
}
|
|
|
|
setFloatOutputForce(flag) {
|
|
this.floatOutputForce = flag;
|
|
return this;
|
|
}
|
|
|
|
setFloatTextures(flag) {
|
|
this.floatTextures = flag;
|
|
return this;
|
|
}
|
|
|
|
constructor(source, settings) {
|
|
super(source, settings);
|
|
this.texSize = null;
|
|
this.floatTextures = null;
|
|
this.floatOutput = null;
|
|
this.floatOutputForce = null;
|
|
this.fixIntegerDivisionAccuracy = null;
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
GLKernel
|
|
};
|
|
},{"./kernel":12}],11:[function(require,module,exports){
|
|
const getContext = require('gl');
|
|
const {
|
|
WebGLKernel
|
|
} = require('../web-gl/kernel');
|
|
|
|
let isSupported = null;
|
|
let testCanvas = null;
|
|
let testContext = null;
|
|
let testExtensions = null;
|
|
let features = null;
|
|
|
|
class HeadlessGLKernel extends WebGLKernel {
|
|
static get isSupported() {
|
|
if (isSupported !== null) return isSupported;
|
|
this.setupFeatureChecks();
|
|
isSupported = testContext !== null;
|
|
return isSupported;
|
|
}
|
|
|
|
static setupFeatureChecks() {
|
|
testCanvas = null;
|
|
testExtensions = null;
|
|
if (typeof getContext !== 'function') return;
|
|
testContext = getContext(2, 2, {
|
|
preserveDrawingBuffer: true
|
|
});
|
|
testExtensions = {
|
|
STACKGL_resize_drawingbuffer: testContext.getExtension('STACKGL_resize_drawingbuffer'),
|
|
STACKGL_destroy_context: testContext.getExtension('STACKGL_destroy_context'),
|
|
OES_texture_float: testContext.getExtension('OES_texture_float'),
|
|
OES_texture_float_linear: testContext.getExtension('OES_texture_float_linear'),
|
|
OES_element_index_uint: testContext.getExtension('OES_element_index_uint'),
|
|
};
|
|
features = this.getFeatures();
|
|
}
|
|
|
|
static isContextMatch(context) {
|
|
try {
|
|
return context.getParameter(context.RENDERER) === 'ANGLE';
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static getFeatures() {
|
|
const isDrawBuffers = this.getIsDrawBuffers();
|
|
return Object.freeze({
|
|
isFloatRead: this.getIsFloatRead(),
|
|
isIntegerDivisionAccurate: this.getIsIntegerDivisionAccurate(),
|
|
getIsTextureFloat: true,
|
|
isDrawBuffers,
|
|
kernelMap: isDrawBuffers
|
|
});
|
|
}
|
|
|
|
static getIsDrawBuffers() {
|
|
return Boolean(testExtensions.WEBGL_draw_buffers);
|
|
}
|
|
|
|
static get testCanvas() {
|
|
return testCanvas;
|
|
}
|
|
|
|
static get testContext() {
|
|
return testContext;
|
|
}
|
|
|
|
static get features() {
|
|
return features;
|
|
}
|
|
|
|
initCanvas() {
|
|
return {};
|
|
}
|
|
|
|
initContext() {
|
|
const context = getContext(2, 2, {
|
|
preserveDrawingBuffer: true
|
|
});
|
|
return context;
|
|
}
|
|
|
|
initExtensions() {
|
|
this.extensions = {
|
|
STACKGL_resize_drawingbuffer: this.context.getExtension('STACKGL_resize_drawingbuffer'),
|
|
STACKGL_destroy_context: this.context.getExtension('STACKGL_destroy_context'),
|
|
OES_texture_float: this.context.getExtension('OES_texture_float'),
|
|
OES_texture_float_linear: this.context.getExtension('OES_texture_float_linear'),
|
|
OES_element_index_uint: this.context.getExtension('OES_element_index_uint'),
|
|
};
|
|
}
|
|
|
|
destroyExtensions() {
|
|
this.extensions.STACKGL_resize_drawingbuffer = null;
|
|
this.extensions.STACKGL_destroy_context = null;
|
|
this.extensions.OES_texture_float = null;
|
|
this.extensions.OES_texture_float_linear = null;
|
|
this.extensions.OES_element_index_uint = null;
|
|
}
|
|
|
|
static destroyContext(context) {
|
|
const extension = context.getExtension('STACKGL_destroy_context');
|
|
if (extension && extension.destroy) {
|
|
extension.destroy();
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
HeadlessGLKernel
|
|
};
|
|
},{"../web-gl/kernel":16,"gl":2}],12:[function(require,module,exports){
|
|
const {
|
|
utils
|
|
} = require('../utils');
|
|
const {
|
|
Input
|
|
} = require('../input');
|
|
|
|
class Kernel {
|
|
static get isSupported() {
|
|
throw new Error(`"isSupported" not implemented on ${ this.name }`);
|
|
}
|
|
|
|
static isContextMatch(context) {
|
|
throw new Error(`"isContextMatch" not implemented on ${ this.name }`);
|
|
}
|
|
|
|
static getFeatures() {
|
|
throw new Error(`"getFeatures" not implemented on ${ this.name }`);
|
|
}
|
|
|
|
static destroyContext(context) {
|
|
throw new Error(`"destroyContext" called on ${ this.name }`);
|
|
}
|
|
|
|
constructor(source, settings) {
|
|
if (typeof source !== 'object') {
|
|
if (typeof source !== 'string') {
|
|
throw new Error('source not a string');
|
|
}
|
|
if (!utils.isFunctionString(source)) {
|
|
throw new Error('source not a function string');
|
|
}
|
|
}
|
|
|
|
this.argumentNames = typeof source === 'string' ? utils.getArgumentNamesFromString(source) : null;
|
|
this.argumentTypes = null;
|
|
this.argumentSizes = null;
|
|
|
|
this.source = source;
|
|
|
|
this.output = null;
|
|
|
|
this.debug = false;
|
|
|
|
this.graphical = false;
|
|
|
|
this.loopMaxIterations = 0;
|
|
|
|
this.constants = null;
|
|
this.constantTypes = null;
|
|
this.hardcodeConstants = null;
|
|
|
|
this.canvas = null;
|
|
|
|
this.context = null;
|
|
|
|
this.functions = null;
|
|
|
|
this.nativeFunctions = null;
|
|
|
|
this.subKernels = null;
|
|
|
|
this.skipValidate = false;
|
|
this.wraparound = null;
|
|
|
|
this.immutable = false;
|
|
|
|
this.pipeline = false;
|
|
|
|
this.plugins = null;
|
|
}
|
|
|
|
mergeSettings(settings) {
|
|
for (let p in settings) {
|
|
if (!settings.hasOwnProperty(p) || !this.hasOwnProperty(p)) continue;
|
|
this[p] = settings[p];
|
|
}
|
|
if (settings.hasOwnProperty('output') && !Array.isArray(settings.output)) {
|
|
this.setOutput(settings.output);
|
|
}
|
|
if (!this.canvas) this.canvas = this.initCanvas();
|
|
if (!this.context) this.context = this.initContext();
|
|
if (!this.plugins) this.plugins = this.initPlugins(settings);
|
|
}
|
|
build() {
|
|
throw new Error(`"build" not defined on ${ this.constructor.name }`);
|
|
}
|
|
|
|
run() {
|
|
throw new Error(`"run" not defined on ${ this.constructor.name }`)
|
|
}
|
|
|
|
initCanvas() {
|
|
throw new Error(`"initCanvas" not defined on ${ this.constructor.name }`);
|
|
}
|
|
|
|
initContext() {
|
|
throw new Error(`"initContext" not defined on ${ this.constructor.name }`);
|
|
}
|
|
|
|
initPlugins(settings) {
|
|
throw new Error(`"initPlugins" not defined on ${ this.constructor.name }`);
|
|
}
|
|
|
|
setupArguments(args) {
|
|
this.argumentTypes = [];
|
|
this.argumentSizes = [];
|
|
for (let i = 0; i < args.length; i++) {
|
|
const arg = args[i];
|
|
const argType = utils.getVariableType(arg);
|
|
this.argumentTypes.push(argType === 'Integer' ? 'Number' : argType);
|
|
this.argumentSizes.push(arg.constructor === Input ? arg.size : null);
|
|
}
|
|
|
|
if (this.argumentNames.length !== args.length) {
|
|
throw new Error(`arguments are miss-aligned`);
|
|
}
|
|
}
|
|
|
|
setupConstants() {
|
|
this.constantTypes = {};
|
|
if (this.constants) {
|
|
for (let p in this.constants) {
|
|
this.constantTypes[p] = utils.getVariableType(this.constants[p]);
|
|
}
|
|
}
|
|
}
|
|
|
|
setOutput(output) {
|
|
if (output.hasOwnProperty('x')) {
|
|
if (output.hasOwnProperty('y')) {
|
|
if (output.hasOwnProperty('z')) {
|
|
this.output = [output.x, output.y, output.z];
|
|
} else {
|
|
this.output = [output.x, output.y];
|
|
}
|
|
} else {
|
|
this.output = [output.x];
|
|
}
|
|
} else {
|
|
this.output = output;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
setDebug(flag) {
|
|
this.debug = flag;
|
|
return this;
|
|
}
|
|
|
|
setGraphical(flag) {
|
|
this.graphical = flag;
|
|
return this;
|
|
}
|
|
|
|
setLoopMaxIterations(max) {
|
|
this.loopMaxIterations = max;
|
|
return this;
|
|
}
|
|
|
|
setConstants(constants) {
|
|
this.constants = constants;
|
|
return this;
|
|
}
|
|
|
|
setPipeline(flag) {
|
|
this.pipeline = flag;
|
|
return this;
|
|
}
|
|
|
|
setImmutable(flag) {
|
|
this.immutable = flag;
|
|
return this;
|
|
}
|
|
|
|
setCanvas(canvas) {
|
|
this.canvas = canvas;
|
|
return this;
|
|
}
|
|
|
|
setContext(context) {
|
|
this.context = context;
|
|
return this;
|
|
}
|
|
|
|
setArgumentTypes(argumentTypes) {
|
|
this.argumentTypes = argumentTypes;
|
|
return this;
|
|
}
|
|
|
|
validateSettings() {
|
|
throw new Error(`"validateSettings" not defined on ${ this.constructor.name }`);
|
|
}
|
|
|
|
exec() {
|
|
const args = (arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments));
|
|
return new Promise((accept, reject) => {
|
|
try {
|
|
accept(this.run.apply(this, args));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
});
|
|
}
|
|
|
|
addSubKernel(subKernel) {
|
|
if (this.subKernels === null) {
|
|
this.subKernels = [];
|
|
}
|
|
if (!subKernel.source) throw new Error('subKernel missing "source" property');
|
|
if (!subKernel.property && isNaN(subKernel.property)) throw new Error('subKernel missing "property" property');
|
|
if (!subKernel.name) throw new Error('subKernel missing "name" property');
|
|
this.subKernels.push(subKernel);
|
|
return this;
|
|
}
|
|
|
|
destroy(removeCanvasReferences) {
|
|
throw new Error(`"destroy" called on ${ this.constructor.name }`);
|
|
}
|
|
|
|
checkOutput() {
|
|
if (!this.output || !Array.isArray(this.output)) throw new Error('kernel.output not an array');
|
|
if (this.output.length < 1) throw new Error('kernel.output is empty, needs at least 1 value');
|
|
for (let i = 0; i < this.output.length; i++) {
|
|
if (isNaN(this.output[i]) || this.output[i] < 1) {
|
|
throw new Error(`${ this.constructor.name }.output[${ i }] incorrectly defined as \`${ this.output[i] }\`, needs to be numeric, and greater than 0`);
|
|
}
|
|
}
|
|
}
|
|
|
|
toJSON() {
|
|
const settings = {
|
|
output: this.output,
|
|
threadDim: this.threadDim,
|
|
pipeline: this.pipeline,
|
|
argumentNames: this.argumentNames,
|
|
argumentsTypes: this.argumentTypes,
|
|
argumentsLength: this.argumentsLength,
|
|
constants: this.constants,
|
|
constantsLength: this.constantsLength,
|
|
pluginNames: this.plugins ? this.plugins.map(plugin => plugin.name) : null,
|
|
};
|
|
return {
|
|
settings
|
|
};
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
Kernel
|
|
};
|
|
},{"../input":25,"../utils":29}],13:[function(require,module,exports){
|
|
const fragmentShader = `__HEADER__;
|
|
precision highp float;
|
|
precision highp int;
|
|
precision highp sampler2D;
|
|
|
|
const int LOOP_MAX = __LOOP_MAX__;
|
|
|
|
__PLUGINS__;
|
|
__CONSTANTS__;
|
|
|
|
varying vec2 vTexCoord;
|
|
|
|
vec4 round(vec4 x) {
|
|
return floor(x + 0.5);
|
|
}
|
|
|
|
float round(float x) {
|
|
return floor(x + 0.5);
|
|
}
|
|
|
|
vec2 integerMod(vec2 x, float y) {
|
|
vec2 res = floor(mod(x, y));
|
|
return res * step(1.0 - floor(y), -res);
|
|
}
|
|
|
|
vec3 integerMod(vec3 x, float y) {
|
|
vec3 res = floor(mod(x, y));
|
|
return res * step(1.0 - floor(y), -res);
|
|
}
|
|
|
|
vec4 integerMod(vec4 x, vec4 y) {
|
|
vec4 res = floor(mod(x, y));
|
|
return res * step(1.0 - floor(y), -res);
|
|
}
|
|
|
|
float integerMod(float x, float y) {
|
|
float res = floor(mod(x, y));
|
|
return res * (res > floor(y) - 1.0 ? 0.0 : 1.0);
|
|
}
|
|
|
|
int integerMod(int x, int y) {
|
|
return x - (y * int(x / y));
|
|
}
|
|
|
|
__DIVIDE_WITH_INTEGER_CHECK__;
|
|
|
|
// Here be dragons!
|
|
// DO NOT OPTIMIZE THIS CODE
|
|
// YOU WILL BREAK SOMETHING ON SOMEBODY\'S MACHINE
|
|
// LEAVE IT AS IT IS, LEST YOU WASTE YOUR OWN TIME
|
|
const vec2 MAGIC_VEC = vec2(1.0, -256.0);
|
|
const vec4 SCALE_FACTOR = vec4(1.0, 256.0, 65536.0, 0.0);
|
|
const vec4 SCALE_FACTOR_INV = vec4(1.0, 0.00390625, 0.0000152587890625, 0.0); // 1, 1/256, 1/65536
|
|
float decode32(vec4 rgba) {
|
|
__DECODE32_ENDIANNESS__;
|
|
rgba *= 255.0;
|
|
vec2 gte128;
|
|
gte128.x = rgba.b >= 128.0 ? 1.0 : 0.0;
|
|
gte128.y = rgba.a >= 128.0 ? 1.0 : 0.0;
|
|
float exponent = 2.0 * rgba.a - 127.0 + dot(gte128, MAGIC_VEC);
|
|
float res = exp2(round(exponent));
|
|
rgba.b = rgba.b - 128.0 * gte128.x;
|
|
res = dot(rgba, SCALE_FACTOR) * exp2(round(exponent-23.0)) + res;
|
|
res *= gte128.y * -2.0 + 1.0;
|
|
return res;
|
|
}
|
|
|
|
vec4 encode32(float f) {
|
|
float F = abs(f);
|
|
float sign = f < 0.0 ? 1.0 : 0.0;
|
|
float exponent = floor(log2(F));
|
|
float mantissa = (exp2(-exponent) * F);
|
|
// exponent += floor(log2(mantissa));
|
|
vec4 rgba = vec4(F * exp2(23.0-exponent)) * SCALE_FACTOR_INV;
|
|
rgba.rg = integerMod(rgba.rg, 256.0);
|
|
rgba.b = integerMod(rgba.b, 128.0);
|
|
rgba.a = exponent*0.5 + 63.5;
|
|
rgba.ba += vec2(integerMod(exponent+127.0, 2.0), sign) * 128.0;
|
|
rgba = floor(rgba);
|
|
rgba *= 0.003921569; // 1/255
|
|
__ENCODE32_ENDIANNESS__;
|
|
return rgba;
|
|
}
|
|
// Dragons end here
|
|
|
|
float decode(vec4 rgba, int x, int bitRatio) {
|
|
if (bitRatio == 1) {
|
|
return decode32(rgba);
|
|
}
|
|
__DECODE32_ENDIANNESS__;
|
|
int channel = integerMod(x, bitRatio);
|
|
if (bitRatio == 4) {
|
|
if (channel == 0) return rgba.r * 255.0;
|
|
if (channel == 1) return rgba.g * 255.0;
|
|
if (channel == 2) return rgba.b * 255.0;
|
|
if (channel == 3) return rgba.a * 255.0;
|
|
}
|
|
else {
|
|
if (channel == 0) return rgba.r * 255.0 + rgba.g * 65280.0;
|
|
if (channel == 1) return rgba.b * 255.0 + rgba.a * 65280.0;
|
|
}
|
|
}
|
|
|
|
int index;
|
|
ivec3 threadId;
|
|
|
|
ivec3 indexTo3D(int idx, ivec3 texDim) {
|
|
int z = int(idx / (texDim.x * texDim.y));
|
|
idx -= z * int(texDim.x * texDim.y);
|
|
int y = int(idx / texDim.x);
|
|
int x = int(integerMod(idx, texDim.x));
|
|
return ivec3(x, y, z);
|
|
}
|
|
|
|
float get(sampler2D tex, ivec2 texSize, ivec3 texDim, int bitRatio, int z, int y, int x) {
|
|
ivec3 xyz = ivec3(x, y, z);
|
|
__GET_WRAPAROUND__;
|
|
int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);
|
|
__GET_TEXTURE_CHANNEL__;
|
|
int w = texSize.x;
|
|
vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;
|
|
__GET_TEXTURE_INDEX__;
|
|
vec4 texel = texture2D(tex, st / vec2(texSize));
|
|
__GET_RESULT__;
|
|
}
|
|
|
|
vec4 getImage2D(sampler2D tex, ivec2 texSize, ivec3 texDim, int z, int y, int x) {
|
|
ivec3 xyz = ivec3(x, y, z);
|
|
__GET_WRAPAROUND__;
|
|
int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);
|
|
__GET_TEXTURE_CHANNEL__;
|
|
int w = texSize.x;
|
|
vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;
|
|
__GET_TEXTURE_INDEX__;
|
|
return texture2D(tex, st / vec2(texSize));
|
|
}
|
|
|
|
vec4 actualColor;
|
|
void color(float r, float g, float b, float a) {
|
|
actualColor = vec4(r,g,b,a);
|
|
}
|
|
|
|
void color(float r, float g, float b) {
|
|
color(r,g,b,1.0);
|
|
}
|
|
|
|
void color(sampler2D image) {
|
|
actualColor = texture2D(image, vTexCoord);
|
|
}
|
|
|
|
__MAIN_CONSTANTS__;
|
|
__MAIN_ARGUMENTS__;
|
|
__KERNEL__;
|
|
|
|
void main(void) {
|
|
index = int(vTexCoord.s * float(uTexSize.x)) + int(vTexCoord.t * float(uTexSize.y)) * uTexSize.x;
|
|
__MAIN_RESULT__;
|
|
}`;
|
|
|
|
module.exports = {
|
|
fragmentShader
|
|
};
|
|
},{}],14:[function(require,module,exports){
|
|
const {
|
|
FunctionNode
|
|
} = require('../function-node');
|
|
const jsMathPrefix = 'Math.';
|
|
const localPrefix = 'this.';
|
|
|
|
class WebGLFunctionNode extends FunctionNode {
|
|
constructor(source, settings) {
|
|
super(source, settings);
|
|
this.fixIntegerDivisionAccuracy = null;
|
|
if (settings && settings.hasOwnProperty('fixIntegerDivisionAccuracy')) {
|
|
this.fixIntegerDivisionAccuracy = settings.fixIntegerDivisionAccuracy;
|
|
}
|
|
}
|
|
|
|
astFunctionExpression(ast, retArr) {
|
|
|
|
if (this.isRootKernel) {
|
|
retArr.push('void');
|
|
} else {
|
|
const {
|
|
returnType
|
|
} = this;
|
|
const type = typeMap[returnType];
|
|
if (!type) {
|
|
throw new Error(`unknown type ${ returnType }`);
|
|
}
|
|
retArr.push(type);
|
|
}
|
|
retArr.push(' ');
|
|
retArr.push(this.name);
|
|
retArr.push('(');
|
|
|
|
if (!this.isRootKernel) {
|
|
for (let i = 0; i < this.argumentNames.length; ++i) {
|
|
const argumentName = this.argumentNames[i];
|
|
|
|
if (i > 0) {
|
|
retArr.push(', ');
|
|
}
|
|
let argumentType = this.getVariableType(argumentName);
|
|
if (!argumentType || argumentType === 'LiteralInteger') {
|
|
argumentType = 'Number';
|
|
}
|
|
const type = typeMap[argumentType];
|
|
if (!type) {
|
|
throw this.astErrorOutput('Unexpected expression', ast);
|
|
}
|
|
retArr.push(type);
|
|
retArr.push(' ');
|
|
retArr.push('user_');
|
|
retArr.push(argumentName);
|
|
}
|
|
}
|
|
|
|
retArr.push(') {\n');
|
|
|
|
for (let i = 0; i < ast.body.body.length; ++i) {
|
|
this.astGeneric(ast.body.body[i], retArr);
|
|
retArr.push('\n');
|
|
}
|
|
|
|
retArr.push('}\n');
|
|
return retArr;
|
|
}
|
|
|
|
astReturnStatement(ast, retArr) {
|
|
if (!ast.argument) throw this.astErrorOutput('Unexpected return statement', ast);
|
|
const type = this.getType(ast.argument);
|
|
|
|
const result = [];
|
|
|
|
switch (this.returnType) {
|
|
case 'Number':
|
|
case 'Float':
|
|
switch (type) {
|
|
case 'Integer':
|
|
result.push('float(');
|
|
this.astGeneric(ast.argument, result);
|
|
result.push(')');
|
|
break;
|
|
case 'LiteralInteger':
|
|
this.pushState('casting-to-float');
|
|
this.astGeneric(ast.argument, result);
|
|
this.popState('casting-to-float');
|
|
break;
|
|
default:
|
|
this.astGeneric(ast.argument, result);
|
|
}
|
|
break;
|
|
case 'Integer':
|
|
switch (type) {
|
|
case 'Number':
|
|
this.pushState('casting-to-integer');
|
|
result.push('int(');
|
|
this.astGeneric(ast.argument, result);
|
|
result.push(')');
|
|
this.popState('casting-to-integer');
|
|
break;
|
|
case 'LiteralInteger':
|
|
this.pushState('casting-to-integer');
|
|
this.astGeneric(ast.argument, result);
|
|
this.popState('casting-to-integer');
|
|
break;
|
|
default:
|
|
this.astGeneric(ast.argument, result);
|
|
}
|
|
break;
|
|
case 'Array(4)':
|
|
case 'Array(3)':
|
|
case 'Array(2)':
|
|
this.astGeneric(ast.argument, result);
|
|
break;
|
|
default:
|
|
throw this.astErrorOutput('Unknown return handler', ast);
|
|
}
|
|
|
|
if (this.isRootKernel) {
|
|
retArr.push(`kernelResult = ${ result.join('') };`);
|
|
retArr.push('return;');
|
|
} else if (this.isSubKernel) {
|
|
retArr.push(`subKernelResult_${ this.name } = ${ result.join('') };`);
|
|
retArr.push(`return subKernelResult_${ this.name };`);
|
|
} else {
|
|
retArr.push(`return ${ result.join('') };`);
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
astLiteral(ast, retArr) {
|
|
|
|
if (isNaN(ast.value)) {
|
|
throw this.astErrorOutput(
|
|
'Non-numeric literal not supported : ' + ast.value,
|
|
ast
|
|
);
|
|
}
|
|
|
|
if (Number.isInteger(ast.value)) {
|
|
if (this.isState('in-for-loop-init') || this.isState('casting-to-integer')) {
|
|
retArr.push(`${ast.value}`);
|
|
} else if (this.isState('casting-to-float')) {
|
|
retArr.push(`${ast.value}.0`);
|
|
} else {
|
|
retArr.push(`${ast.value}.0`);
|
|
}
|
|
} else if (this.isState('casting-to-integer')) {
|
|
retArr.push(parseInt(ast.raw));
|
|
} else {
|
|
retArr.push(`${ast.value}`);
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
astBinaryExpression(ast, retArr) {
|
|
if (ast.operator === '%') {
|
|
retArr.push('mod(');
|
|
|
|
const leftType = this.getType(ast.left);
|
|
if (leftType === 'Integer') {
|
|
retArr.push('float(');
|
|
this.astGeneric(ast.left, retArr);
|
|
retArr.push(')');
|
|
} else if (leftType === 'LiteralInteger') {
|
|
this.pushState('casting-to-float');
|
|
this.astGeneric(ast.left, retArr);
|
|
this.popState('casting-to-float');
|
|
} else {
|
|
this.astGeneric(ast.left, retArr);
|
|
}
|
|
|
|
retArr.push(',');
|
|
const rightType = this.getType(ast.right);
|
|
|
|
if (rightType === 'Integer') {
|
|
retArr.push('float(');
|
|
this.astGeneric(ast.right, retArr);
|
|
retArr.push(')');
|
|
} else if (rightType === 'LiteralInteger') {
|
|
this.pushState('casting-to-float');
|
|
this.astGeneric(ast.right, retArr);
|
|
this.popState('casting-to-float');
|
|
} else {
|
|
this.astGeneric(ast.right, retArr);
|
|
}
|
|
retArr.push(')');
|
|
return retArr;
|
|
}
|
|
|
|
retArr.push('(');
|
|
if (this.fixIntegerDivisionAccuracy && ast.operator === '/') {
|
|
retArr.push('div_with_int_check(');
|
|
|
|
if (this.getType(ast.left) !== 'Number') {
|
|
retArr.push('int(');
|
|
this.pushState('casting-to-float');
|
|
this.astGeneric(ast.left, retArr);
|
|
this.popState('casting-to-float');
|
|
retArr.push(')');
|
|
} else {
|
|
this.astGeneric(ast.left, retArr);
|
|
}
|
|
|
|
retArr.push(', ');
|
|
|
|
if (this.getType(ast.right) !== 'Number') {
|
|
retArr.push('float(');
|
|
this.pushState('casting-to-float');
|
|
this.astGeneric(ast.right, retArr);
|
|
this.popState('casting-to-float');
|
|
retArr.push(')');
|
|
} else {
|
|
this.astGeneric(ast.right, retArr);
|
|
}
|
|
retArr.push(')');
|
|
} else {
|
|
const leftType = this.getType(ast.left) || 'Number';
|
|
const rightType = this.getType(ast.right) || 'Number';
|
|
if (!leftType || !rightType) {
|
|
throw this.astErrorOutput(`Unhandled binary expression`, ast);
|
|
}
|
|
const key = leftType + ' & ' + rightType;
|
|
switch (key) {
|
|
case 'Integer & Integer':
|
|
this.astGeneric(ast.left, retArr);
|
|
retArr.push(operatorMap[ast.operator] || ast.operator);
|
|
this.astGeneric(ast.right, retArr);
|
|
break;
|
|
case 'Number & Float':
|
|
case 'Float & Number':
|
|
case 'Float & Float':
|
|
case 'Number & Number':
|
|
this.astGeneric(ast.left, retArr);
|
|
retArr.push(operatorMap[ast.operator] || ast.operator);
|
|
this.astGeneric(ast.right, retArr);
|
|
break;
|
|
case 'LiteralInteger & LiteralInteger':
|
|
this.pushState('casting-to-float');
|
|
this.astGeneric(ast.left, retArr);
|
|
retArr.push(operatorMap[ast.operator] || ast.operator);
|
|
this.astGeneric(ast.right, retArr);
|
|
this.popState('casting-to-float');
|
|
break;
|
|
|
|
case 'Integer & Number':
|
|
this.astGeneric(ast.left, retArr);
|
|
retArr.push(operatorMap[ast.operator] || ast.operator);
|
|
this.pushState('casting-to-integer');
|
|
retArr.push('int(');
|
|
this.astGeneric(ast.right, retArr);
|
|
retArr.push(')');
|
|
this.popState('casting-to-integer');
|
|
break;
|
|
case 'Integer & LiteralInteger':
|
|
this.astGeneric(ast.left, retArr);
|
|
retArr.push(operatorMap[ast.operator] || ast.operator);
|
|
this.pushState('casting-to-integer');
|
|
this.astGeneric(ast.right, retArr);
|
|
this.popState('casting-to-integer');
|
|
break;
|
|
|
|
case 'Number & Integer':
|
|
this.astGeneric(ast.left, retArr);
|
|
retArr.push(operatorMap[ast.operator] || ast.operator);
|
|
this.pushState('casting-to-float');
|
|
retArr.push('float(');
|
|
this.astGeneric(ast.right, retArr);
|
|
retArr.push(')');
|
|
this.popState('casting-to-float');
|
|
break;
|
|
case 'Float & LiteralInteger':
|
|
case 'Number & LiteralInteger':
|
|
if (this.isState('force-integer')) {
|
|
retArr.push('int(');
|
|
this.astGeneric(ast.left, retArr);
|
|
retArr.push(')');
|
|
retArr.push(operatorMap[ast.operator] || ast.operator);
|
|
this.pushState('casting-to-integer');
|
|
this.astGeneric(ast.right, retArr);
|
|
this.popState('casting-to-integer');
|
|
} else {
|
|
this.astGeneric(ast.left, retArr);
|
|
retArr.push(operatorMap[ast.operator] || ast.operator);
|
|
this.pushState('casting-to-float');
|
|
this.astGeneric(ast.right, retArr);
|
|
this.popState('casting-to-float');
|
|
}
|
|
break;
|
|
case 'LiteralInteger & Float':
|
|
case 'LiteralInteger & Number':
|
|
if (this.isState('force-integer') || this.isState('in-for-loop-init')) {
|
|
this.pushState('casting-to-integer');
|
|
this.astGeneric(ast.left, retArr);
|
|
retArr.push(operatorMap[ast.operator] || ast.operator);
|
|
retArr.push('int(');
|
|
this.astGeneric(ast.right, retArr);
|
|
retArr.push(')');
|
|
this.popState('casting-to-integer');
|
|
} else {
|
|
this.astGeneric(ast.left, retArr);
|
|
retArr.push(operatorMap[ast.operator] || ast.operator);
|
|
this.pushState('casting-to-float');
|
|
this.astGeneric(ast.right, retArr);
|
|
this.popState('casting-to-float');
|
|
}
|
|
break;
|
|
case 'LiteralInteger & Integer':
|
|
this.pushState('casting-to-integer');
|
|
this.astGeneric(ast.left, retArr);
|
|
this.popState('casting-to-integer');
|
|
retArr.push(operatorMap[ast.operator] || ast.operator);
|
|
this.astGeneric(ast.right, retArr);
|
|
break;
|
|
default:
|
|
throw this.astErrorOutput(`Unhandled binary expression between ${key}`, ast);
|
|
}
|
|
}
|
|
|
|
retArr.push(')');
|
|
return retArr;
|
|
}
|
|
|
|
astIdentifierExpression(idtNode, retArr) {
|
|
if (idtNode.type !== 'Identifier') {
|
|
throw this.astErrorOutput(
|
|
'IdentifierExpression - not an Identifier',
|
|
idtNode
|
|
);
|
|
}
|
|
|
|
if (idtNode.name === 'Infinity') {
|
|
retArr.push('3.402823466e+38');
|
|
} else {
|
|
const userArgumentName = this.getUserArgumentName(idtNode.name);
|
|
if (userArgumentName) {
|
|
retArr.push(`user_${userArgumentName}`);
|
|
} else {
|
|
retArr.push(`user_${idtNode.name}`);
|
|
}
|
|
}
|
|
|
|
return retArr;
|
|
}
|
|
|
|
astForStatement(forNode, retArr) {
|
|
if (forNode.type !== 'ForStatement') {
|
|
throw this.astErrorOutput('Invalid for statement', forNode);
|
|
}
|
|
|
|
const initArr = [];
|
|
const testArr = [];
|
|
const updateArr = [];
|
|
const bodyArr = [];
|
|
let isSafe = null;
|
|
|
|
if (forNode.init) {
|
|
this.pushState('in-for-loop-init');
|
|
this.astGeneric(forNode.init, initArr);
|
|
for (let i = 0; i < initArr.length; i++) {
|
|
if (initArr[i].includes && initArr[i].includes(',')) {
|
|
isSafe = false;
|
|
}
|
|
}
|
|
this.popState('in-for-loop-init');
|
|
} else {
|
|
isSafe = false;
|
|
}
|
|
|
|
if (forNode.test) {
|
|
this.pushState('force-integer');
|
|
this.astGeneric(forNode.test, testArr);
|
|
this.popState('force-integer');
|
|
} else {
|
|
isSafe = false;
|
|
}
|
|
|
|
if (forNode.update) {
|
|
this.astGeneric(forNode.update, updateArr);
|
|
} else {
|
|
isSafe = false;
|
|
}
|
|
|
|
if (forNode.body) {
|
|
this.pushState('loop-body');
|
|
this.astGeneric(forNode.body, bodyArr);
|
|
this.popState('loop-body');
|
|
}
|
|
|
|
if (isSafe === null) {
|
|
isSafe = this.isSafe(forNode.init) && this.isSafe(forNode.test);
|
|
}
|
|
|
|
if (isSafe) {
|
|
retArr.push(`for (${initArr.join('')};${testArr.join('')};${updateArr.join('')}){\n`);
|
|
retArr.push(bodyArr.join(''));
|
|
retArr.push('}\n');
|
|
} else {
|
|
const iVariableName = this.getInternalVariableName('safeI');
|
|
if (initArr.length > 0) {
|
|
retArr.push(initArr.join(''), ';\n');
|
|
}
|
|
retArr.push(`for (int ${iVariableName}=0;${iVariableName}<LOOP_MAX;${iVariableName}++){\n`);
|
|
if (testArr.length > 0) {
|
|
retArr.push(`if (!${testArr.join('')}) break;\n`);
|
|
}
|
|
retArr.push(bodyArr.join(''));
|
|
retArr.push(`\n${updateArr.join('')};`);
|
|
retArr.push('}\n');
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
astWhileStatement(whileNode, retArr) {
|
|
if (whileNode.type !== 'WhileStatement') {
|
|
throw this.astErrorOutput('Invalid while statement', whileNode);
|
|
}
|
|
|
|
const iVariableName = this.getInternalVariableName('safeI');
|
|
retArr.push(`for (int ${iVariableName}=0;${iVariableName}<LOOP_MAX;${iVariableName}++){\n`);
|
|
retArr.push('if (!');
|
|
this.astGeneric(whileNode.test, retArr);
|
|
retArr.push(') break;\n');
|
|
this.astGeneric(whileNode.body, retArr);
|
|
retArr.push('}\n');
|
|
|
|
return retArr;
|
|
}
|
|
|
|
astDoWhileStatement(doWhileNode, retArr) {
|
|
if (doWhileNode.type !== 'DoWhileStatement') {
|
|
throw this.astErrorOutput('Invalid while statement', doWhileNode);
|
|
}
|
|
|
|
const iVariableName = this.getInternalVariableName('safeI');
|
|
retArr.push(`for (int ${iVariableName}=0;${iVariableName}<LOOP_MAX;${iVariableName}++){\n`);
|
|
this.astGeneric(doWhileNode.body, retArr);
|
|
retArr.push('if (!');
|
|
this.astGeneric(doWhileNode.test, retArr);
|
|
retArr.push(') break;\n');
|
|
retArr.push('}\n');
|
|
|
|
return retArr;
|
|
}
|
|
|
|
|
|
astAssignmentExpression(assNode, retArr) {
|
|
if (assNode.operator === '%=') {
|
|
this.astGeneric(assNode.left, retArr);
|
|
retArr.push('=');
|
|
retArr.push('mod(');
|
|
this.astGeneric(assNode.left, retArr);
|
|
retArr.push(',');
|
|
this.astGeneric(assNode.right, retArr);
|
|
retArr.push(')');
|
|
} else {
|
|
const leftType = this.getType(assNode.left);
|
|
const rightType = this.getType(assNode.right);
|
|
this.astGeneric(assNode.left, retArr);
|
|
retArr.push(assNode.operator);
|
|
if (leftType !== 'Integer' && rightType === 'Integer') {
|
|
retArr.push('float(');
|
|
this.astGeneric(assNode.right, retArr);
|
|
retArr.push(')');
|
|
} else {
|
|
this.astGeneric(assNode.right, retArr);
|
|
}
|
|
return retArr;
|
|
}
|
|
}
|
|
|
|
astBlockStatement(bNode, retArr) {
|
|
if (!this.isState('loop-body')) {
|
|
retArr.push('{\n');
|
|
}
|
|
for (let i = 0; i < bNode.body.length; i++) {
|
|
this.astGeneric(bNode.body[i], retArr);
|
|
}
|
|
if (!this.isState('loop-body')) {
|
|
retArr.push('}\n');
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
astVariableDeclaration(varDecNode, retArr) {
|
|
const declarations = varDecNode.declarations;
|
|
if (!declarations || !declarations[0] || !declarations[0].init) {
|
|
throw this.astErrorOutput('Unexpected expression', varDecNode);
|
|
}
|
|
const result = [];
|
|
const firstDeclaration = declarations[0];
|
|
const init = firstDeclaration.init;
|
|
const actualType = this.getType(init);
|
|
let type = this.isState('in-for-loop-init') ? 'Integer' : actualType;
|
|
if (type === 'LiteralInteger') {
|
|
type = 'Number';
|
|
}
|
|
const markupType = typeMap[type];
|
|
if (!markupType) {
|
|
throw this.astErrorOutput(`Markup type ${ markupType } not handled`, varDecNode);
|
|
}
|
|
let dependencies = this.getDependencies(firstDeclaration.init);
|
|
this.declarations[firstDeclaration.id.name] = Object.freeze({
|
|
type,
|
|
dependencies,
|
|
isSafe: this.isSafeDependencies(dependencies),
|
|
});
|
|
const initResult = [];
|
|
initResult.push([`${markupType} `]);
|
|
initResult.push(`user_${firstDeclaration.id.name}=`);
|
|
if (actualType === 'Number' && type === 'Integer') {
|
|
initResult.push('int(');
|
|
this.astGeneric(init, initResult);
|
|
initResult.push(')');
|
|
} else {
|
|
this.astGeneric(init, initResult);
|
|
}
|
|
result.push(initResult.join(''));
|
|
|
|
for (let i = 1; i < declarations.length; i++) {
|
|
const declaration = declarations[i];
|
|
dependencies = this.getDependencies(declaration);
|
|
this.declarations[declaration.id.name] = Object.freeze({
|
|
type,
|
|
dependencies: dependencies,
|
|
isSafe: this.isSafeDependencies(dependencies),
|
|
});
|
|
this.astGeneric(declaration, result);
|
|
}
|
|
|
|
retArr.push(result.join(','));
|
|
if (!this.isState('in-for-loop-init')) {
|
|
retArr.push(';');
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
astIfStatement(ifNode, retArr) {
|
|
retArr.push('if (');
|
|
this.astGeneric(ifNode.test, retArr);
|
|
retArr.push(')');
|
|
if (ifNode.consequent.type === 'BlockStatement') {
|
|
this.astGeneric(ifNode.consequent, retArr);
|
|
} else {
|
|
retArr.push(' {\n');
|
|
this.astGeneric(ifNode.consequent, retArr);
|
|
retArr.push('\n}\n');
|
|
}
|
|
|
|
if (ifNode.alternate) {
|
|
retArr.push('else ');
|
|
if (ifNode.alternate.type === 'BlockStatement') {
|
|
this.astGeneric(ifNode.alternate, retArr);
|
|
} else {
|
|
retArr.push(' {\n');
|
|
this.astGeneric(ifNode.alternate, retArr);
|
|
retArr.push('\n}\n');
|
|
}
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
astThisExpression(tNode, retArr) {
|
|
retArr.push('this');
|
|
return retArr;
|
|
}
|
|
|
|
astMemberExpression(mNode, retArr) {
|
|
const {
|
|
property,
|
|
name,
|
|
signature,
|
|
origin,
|
|
type,
|
|
xProperty,
|
|
yProperty,
|
|
zProperty
|
|
} = this.getMemberExpressionDetails(mNode);
|
|
switch (signature) {
|
|
case 'this.thread.value':
|
|
retArr.push(`threadId.${ name }`);
|
|
return retArr;
|
|
case 'this.output.value':
|
|
switch (name) {
|
|
case 'x':
|
|
retArr.push(this.output[0]);
|
|
break;
|
|
case 'y':
|
|
retArr.push(this.output[1]);
|
|
break;
|
|
case 'z':
|
|
retArr.push(this.output[2]);
|
|
break;
|
|
default:
|
|
throw this.astErrorOutput('Unexpected expression', mNode);
|
|
}
|
|
return retArr;
|
|
case 'value':
|
|
throw this.astErrorOutput('Unexpected expression', mNode);
|
|
case 'value[]':
|
|
case 'value[][]':
|
|
case 'value[][][]':
|
|
case 'value.value':
|
|
if (origin === 'Math') {
|
|
retArr.push(Math[name]);
|
|
return retArr;
|
|
}
|
|
switch (property) {
|
|
case 'r':
|
|
retArr.push(`user_${ name }.r`);
|
|
return retArr;
|
|
case 'g':
|
|
retArr.push(`user_${ name }.g`);
|
|
return retArr;
|
|
case 'b':
|
|
retArr.push(`user_${ name }.b`);
|
|
return retArr;
|
|
case 'a':
|
|
retArr.push(`user_${ name }.a`);
|
|
return retArr;
|
|
}
|
|
break;
|
|
case 'this.constants.value':
|
|
case 'this.constants.value[]':
|
|
case 'this.constants.value[][]':
|
|
case 'this.constants.value[][][]':
|
|
break;
|
|
case 'fn()[]':
|
|
this.astCallExpression(mNode.object, retArr);
|
|
retArr.push('[');
|
|
retArr.push(this.memberExpressionPropertyMarkup(property));
|
|
retArr.push(']');
|
|
return retArr;
|
|
default:
|
|
throw this.astErrorOutput('Unexpected expression', mNode);
|
|
}
|
|
|
|
if (type === 'Number' || type === 'Integer') {
|
|
retArr.push(`${ origin }_${ name}`);
|
|
return retArr;
|
|
}
|
|
|
|
let synonymName;
|
|
if (this.parent) {
|
|
synonymName = this.getUserArgumentName(name);
|
|
}
|
|
|
|
const markupName = `${origin}_${synonymName || name}`;
|
|
|
|
switch (type) {
|
|
case 'Array(2)':
|
|
case 'Array(3)':
|
|
case 'Array(4)':
|
|
this.astGeneric(mNode.object, retArr);
|
|
retArr.push('[');
|
|
retArr.push(this.memberExpressionPropertyMarkup(xProperty));
|
|
retArr.push(']');
|
|
break;
|
|
case 'HTMLImageArray':
|
|
retArr.push(`getImage3D(${ markupName }, ${ markupName }Size, ${ markupName }Dim, `);
|
|
this.memberExpressionXYZ(xProperty, yProperty, zProperty, retArr);
|
|
retArr.push(')');
|
|
break;
|
|
case 'ArrayTexture(4)':
|
|
case 'HTMLImage':
|
|
retArr.push(`getImage2D(${ markupName }, ${ markupName }Size, ${ markupName }Dim, `);
|
|
this.memberExpressionXYZ(xProperty, yProperty, zProperty, retArr);
|
|
retArr.push(')');
|
|
break;
|
|
default:
|
|
retArr.push(`get(${ markupName }, ${ markupName }Size, ${ markupName }Dim, ${ markupName }BitRatio, `);
|
|
this.memberExpressionXYZ(xProperty, yProperty, zProperty, retArr);
|
|
retArr.push(')');
|
|
break;
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
astCallExpression(ast, retArr) {
|
|
if (ast.callee) {
|
|
let funcName = this.astMemberExpressionUnroll(ast.callee);
|
|
|
|
if (funcName.indexOf(jsMathPrefix) === 0) {
|
|
funcName = funcName.slice(jsMathPrefix.length);
|
|
}
|
|
|
|
if (funcName.indexOf(localPrefix) === 0) {
|
|
funcName = funcName.slice(localPrefix.length);
|
|
}
|
|
|
|
if (funcName === 'atan2') {
|
|
funcName = 'atan';
|
|
}
|
|
|
|
if (this.calledFunctions.indexOf(funcName) < 0) {
|
|
this.calledFunctions.push(funcName);
|
|
}
|
|
if (!this.calledFunctionsArguments[funcName]) {
|
|
this.calledFunctionsArguments[funcName] = [];
|
|
}
|
|
|
|
const functionArguments = [];
|
|
this.calledFunctionsArguments[funcName].push(functionArguments);
|
|
|
|
if (funcName === 'random' && this.plugins) {
|
|
for (let i = 0; i < this.plugins.length; i++) {
|
|
const plugin = this.plugins[i];
|
|
if (plugin.functionMatch === 'Math.random()' && plugin.functionReplace) {
|
|
functionArguments.push(plugin.functionReturnType);
|
|
retArr.push(plugin.functionReplace);
|
|
}
|
|
}
|
|
return retArr;
|
|
}
|
|
|
|
retArr.push(funcName);
|
|
|
|
retArr.push('(');
|
|
|
|
for (let i = 0; i < ast.arguments.length; ++i) {
|
|
const argument = ast.arguments[i];
|
|
if (i > 0) {
|
|
retArr.push(', ');
|
|
}
|
|
this.astGeneric(argument, retArr);
|
|
const argumentType = this.getType(argument);
|
|
if (argumentType) {
|
|
functionArguments.push({
|
|
name: argument.name || null,
|
|
type: argumentType
|
|
});
|
|
} else {
|
|
functionArguments.push(null);
|
|
}
|
|
}
|
|
|
|
retArr.push(')');
|
|
|
|
return retArr;
|
|
}
|
|
|
|
throw this.astErrorOutput(
|
|
'Unknown CallExpression',
|
|
ast
|
|
);
|
|
}
|
|
|
|
astArrayExpression(arrNode, retArr) {
|
|
const arrLen = arrNode.elements.length;
|
|
|
|
retArr.push('vec' + arrLen + '(');
|
|
for (let i = 0; i < arrLen; ++i) {
|
|
if (i > 0) {
|
|
retArr.push(', ');
|
|
}
|
|
const subNode = arrNode.elements[i];
|
|
this.astGeneric(subNode, retArr)
|
|
}
|
|
retArr.push(')');
|
|
|
|
return retArr;
|
|
}
|
|
|
|
memberExpressionXYZ(x, y, z, retArr) {
|
|
if (z) {
|
|
retArr.push(this.memberExpressionPropertyMarkup(z), ', ');
|
|
} else {
|
|
retArr.push('0, ');
|
|
}
|
|
if (y) {
|
|
retArr.push(this.memberExpressionPropertyMarkup(y), ', ');
|
|
} else {
|
|
retArr.push('0, ');
|
|
}
|
|
retArr.push(this.memberExpressionPropertyMarkup(x));
|
|
return retArr;
|
|
}
|
|
|
|
memberExpressionPropertyMarkup(property) {
|
|
if (!property) {
|
|
throw new Error('Property not set');
|
|
}
|
|
const type = this.getType(property);
|
|
const result = [];
|
|
if (type === 'Number') {
|
|
this.pushState('casting-to-integer');
|
|
result.push('int(');
|
|
this.astGeneric(property, result);
|
|
result.push(')');
|
|
this.popState('casting-to-integer');
|
|
} else if (type === 'LiteralInteger') {
|
|
this.pushState('casting-to-integer');
|
|
this.astGeneric(property, result);
|
|
this.popState('casting-to-integer');
|
|
} else {
|
|
this.astGeneric(property, result);
|
|
}
|
|
return result.join('');
|
|
}
|
|
}
|
|
|
|
const typeMap = {
|
|
'Array': 'sampler2D',
|
|
'Array(2)': 'vec2',
|
|
'Array(3)': 'vec3',
|
|
'Array(4)': 'vec4',
|
|
'Array2D': 'sampler2D',
|
|
'Array3D': 'sampler2D',
|
|
'Float': 'float',
|
|
'Input': 'sampler2D',
|
|
'Integer': 'int',
|
|
'Number': 'float',
|
|
'NumberTexture': 'sampler2D',
|
|
'ArrayTexture(4)': 'sampler2D'
|
|
};
|
|
|
|
const operatorMap = {
|
|
'===': '==',
|
|
'!==': '!='
|
|
};
|
|
|
|
module.exports = {
|
|
WebGLFunctionNode
|
|
};
|
|
},{"../function-node":9}],15:[function(require,module,exports){
|
|
const {
|
|
utils
|
|
} = require('../../utils');
|
|
const {
|
|
kernelRunShortcut
|
|
} = require('../../kernel-run-shortcut');
|
|
|
|
function removeFnNoise(fn) {
|
|
if (/^function /.test(fn)) {
|
|
fn = fn.substring(9);
|
|
}
|
|
return fn.replace(/[_]typeof/g, 'typeof');
|
|
}
|
|
|
|
function removeNoise(str) {
|
|
return str
|
|
.replace(/^[A-Za-z23]+/, 'function')
|
|
.replace(/[_]typeof/g, 'typeof');
|
|
}
|
|
|
|
function boolToString(value) {
|
|
if (value) {
|
|
return 'true';
|
|
} else if (value === false) {
|
|
return 'false';
|
|
}
|
|
return 'null';
|
|
}
|
|
|
|
function webGLKernelString(gpuKernel, name) {
|
|
return `() => {
|
|
${ kernelRunShortcut.toString() };
|
|
const utils = {
|
|
allPropertiesOf: ${ removeNoise(utils.allPropertiesOf.toString()) },
|
|
clone: ${ removeNoise(utils.clone.toString()) },
|
|
splitArray: ${ removeNoise(utils.splitArray.toString()) },
|
|
getVariableType: ${ removeNoise(utils.getVariableType.toString()) },
|
|
getDimensions: ${ removeNoise(utils.getDimensions.toString()) },
|
|
dimToTexSize: ${ removeNoise(utils.dimToTexSize.toString()) },
|
|
flattenTo: ${ removeNoise(utils.flattenTo.toString()) },
|
|
flatten2dArrayTo: ${ removeNoise(utils.flatten2dArrayTo.toString()) },
|
|
flatten3dArrayTo: ${ removeNoise(utils.flatten3dArrayTo.toString()) },
|
|
systemEndianness: ${ removeNoise(utils.getSystemEndianness.toString()) },
|
|
isArray: ${ removeNoise(utils.isArray.toString()) }
|
|
};
|
|
const canvases = [];
|
|
const maxTexSizes = {};
|
|
let Texture = function() {};
|
|
let Input = function() {};
|
|
class ${ name || 'Kernel' } {
|
|
constructor() {
|
|
this.maxTexSize = null;
|
|
this.argumentsLength = 0;
|
|
this.constantsLength = 0;
|
|
this.canvas = null;
|
|
this.context = null;
|
|
this.program = null;
|
|
this.subKernels = null;
|
|
this.subKernelNames = null;
|
|
this.wraparound = null;
|
|
this.drawBuffersMap = ${ gpuKernel.drawBuffersMap ? JSON.stringify(gpuKernel.drawBuffersMap) : 'null' };
|
|
this.endianness = '${ gpuKernel.endianness }';
|
|
this.graphical = ${ boolToString(gpuKernel.graphical) };
|
|
this.floatTextures = ${ boolToString(gpuKernel.floatTextures) };
|
|
this.floatOutput = ${ boolToString(gpuKernel.floatOutput) };
|
|
this.floatOutputForce = ${ boolToString(gpuKernel.floatOutputForce) };
|
|
this.hardcodeConstants = ${ boolToString(gpuKernel.hardcodeConstants) };
|
|
this.pipeline = ${ boolToString(gpuKernel.pipeline) };
|
|
this.argumentNames = ${ JSON.stringify(gpuKernel.argumentNames) };
|
|
this.argumentTypes = ${ JSON.stringify(gpuKernel.argumentTypes) };
|
|
this.texSize = ${ JSON.stringify(gpuKernel.texSize) };
|
|
this.output = ${ JSON.stringify(gpuKernel.output) };
|
|
this.compiledFragmentShader = \`${ gpuKernel.compiledFragmentShader }\`;
|
|
this.compiledVertexShader = \`${ gpuKernel.compiledVertexShader }\`;
|
|
this.programUniformLocationCache = {};
|
|
this.textureCache = {};
|
|
this.subKernelOutputTextures = null;
|
|
this.extensions = {};
|
|
this.uniform1fCache = {};
|
|
this.uniform1iCache = {};
|
|
this.uniform2fCache = {};
|
|
this.uniform2fvCache = {};
|
|
this.uniform2ivCache = {};
|
|
this.uniform3fvCache = {};
|
|
this.uniform3ivCache = {};
|
|
}
|
|
getFragmentShader() { return this.compiledFragmentShader; }
|
|
getVertexShader() { return this.compiledVertexShader; }
|
|
validateSettings() {}
|
|
initExtensions() {}
|
|
setupArguments() {}
|
|
setupConstants() {}
|
|
setCanvas(canvas) { this.canvas = canvas; return this; }
|
|
setContext(context) { this.context = context; return this; }
|
|
setTexture(Type) { Texture = Type; }
|
|
setInput(Type) { Input = Type; }
|
|
${ removeFnNoise(gpuKernel.getUniformLocation.toString()) }
|
|
${ removeFnNoise(gpuKernel.build.toString()) }
|
|
${ removeFnNoise(gpuKernel.run.toString()) }
|
|
${ removeFnNoise(gpuKernel._addArgument.toString()) }
|
|
${ removeFnNoise(gpuKernel._formatArrayTransfer.toString()) }
|
|
${ removeFnNoise(gpuKernel.checkOutput.toString()) }
|
|
${ removeFnNoise(gpuKernel.getArgumentTexture.toString()) }
|
|
${ removeFnNoise(gpuKernel.getTextureCache.toString()) }
|
|
${ removeFnNoise(gpuKernel.getOutputTexture.toString()) }
|
|
${ removeFnNoise(gpuKernel.renderOutput.toString()) }
|
|
${ removeFnNoise(gpuKernel.updateMaxTexSize.toString()) }
|
|
${ removeFnNoise(gpuKernel._setupOutputTexture.toString()) }
|
|
${ removeFnNoise(gpuKernel.detachTextureCache.toString()) }
|
|
${ removeFnNoise(gpuKernel.setUniform1f.toString()) }
|
|
${ removeFnNoise(gpuKernel.setUniform1i.toString()) }
|
|
${ removeFnNoise(gpuKernel.setUniform2f.toString()) }
|
|
${ removeFnNoise(gpuKernel.setUniform2fv.toString()) }
|
|
${ removeFnNoise(gpuKernel.setUniform2iv.toString()) }
|
|
${ removeFnNoise(gpuKernel.setUniform3fv.toString()) }
|
|
${ removeFnNoise(gpuKernel.setUniform3iv.toString()) }
|
|
};
|
|
return kernelRunShortcut(new ${ name || 'Kernel' }());
|
|
};`;
|
|
}
|
|
|
|
module.exports = {
|
|
webGLKernelString
|
|
};
|
|
},{"../../kernel-run-shortcut":26,"../../utils":29}],16:[function(require,module,exports){
|
|
const {
|
|
GLKernel
|
|
} = require('../gl-kernel');
|
|
const {
|
|
FunctionBuilder
|
|
} = require('../function-builder');
|
|
const {
|
|
WebGLFunctionNode
|
|
} = require('./function-node');
|
|
const {
|
|
utils
|
|
} = require('../../utils');
|
|
const {
|
|
Texture
|
|
} = require('../../texture');
|
|
const triangleNoise = require('../../plugins/triangle-noise');
|
|
const {
|
|
fragmentShader
|
|
} = require('./fragment-shader');
|
|
const {
|
|
vertexShader
|
|
} = require('./vertex-shader');
|
|
const {
|
|
webGLKernelString
|
|
} = require('./kernel-string');
|
|
|
|
let isSupported = null;
|
|
let testCanvas = null;
|
|
let testContext = null;
|
|
let testExtensions = null;
|
|
let features = null;
|
|
|
|
const plugins = [triangleNoise];
|
|
const canvases = [];
|
|
const maxTexSizes = {};
|
|
|
|
class WebGLKernel extends GLKernel {
|
|
static get isSupported() {
|
|
if (isSupported !== null) {
|
|
return isSupported;
|
|
}
|
|
this.setupFeatureChecks();
|
|
isSupported = this.isContextMatch(testContext);
|
|
return isSupported;
|
|
}
|
|
|
|
static setupFeatureChecks() {
|
|
if (typeof document !== 'undefined') {
|
|
testCanvas = document.createElement('canvas');
|
|
} else if (typeof OffscreenCanvas !== 'undefined') {
|
|
testCanvas = new OffscreenCanvas(0, 0);
|
|
}
|
|
|
|
if (testCanvas) {
|
|
testContext = testCanvas.getContext('webgl') || testCanvas.getContext('experimental-webgl');
|
|
testExtensions = {
|
|
OES_texture_float: testContext.getExtension('OES_texture_float'),
|
|
OES_texture_float_linear: testContext.getExtension('OES_texture_float_linear'),
|
|
OES_element_index_uint: testContext.getExtension('OES_element_index_uint'),
|
|
WEBGL_draw_buffers: testContext.getExtension('WEBGL_draw_buffers'),
|
|
};
|
|
features = this.getFeatures();
|
|
}
|
|
}
|
|
|
|
static isContextMatch(context) {
|
|
if (typeof WebGLRenderingContext !== 'undefined') {
|
|
return context instanceof WebGLRenderingContext;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static getFeatures() {
|
|
const isDrawBuffers = this.getIsDrawBuffers();
|
|
return Object.freeze({
|
|
isFloatRead: this.getIsFloatRead(),
|
|
isIntegerDivisionAccurate: this.getIsIntegerDivisionAccurate(),
|
|
isTextureFloat: this.getIsTextureFloat(),
|
|
isDrawBuffers,
|
|
kernelMap: isDrawBuffers
|
|
});
|
|
}
|
|
|
|
static getIsTextureFloat() {
|
|
return Boolean(testExtensions.OES_texture_float);
|
|
}
|
|
|
|
static getIsDrawBuffers() {
|
|
return Boolean(testExtensions.WEBGL_draw_buffers);
|
|
}
|
|
|
|
static get testCanvas() {
|
|
return testCanvas;
|
|
}
|
|
|
|
static get testContext() {
|
|
return testContext;
|
|
}
|
|
|
|
static get features() {
|
|
return features;
|
|
}
|
|
|
|
static get fragmentShader() {
|
|
return fragmentShader;
|
|
}
|
|
|
|
static get vertexShader() {
|
|
return vertexShader;
|
|
}
|
|
|
|
constructor(source, settings) {
|
|
super(source, settings);
|
|
this.textureCache = {};
|
|
this.threadDim = {};
|
|
this.programUniformLocationCache = {};
|
|
this.framebuffer = null;
|
|
|
|
this.buffer = null;
|
|
this.program = null;
|
|
this.pipeline = settings.pipeline;
|
|
this.endianness = utils.systemEndianness();
|
|
this.extensions = {};
|
|
this.subKernelOutputTextures = null;
|
|
this.argumentsLength = 0;
|
|
this.constantsLength = 0;
|
|
this.compiledFragmentShader = null;
|
|
this.compiledVertexShader = null;
|
|
this.fragShader = null;
|
|
this.vertShader = null;
|
|
this.drawBuffersMap = null;
|
|
this.outputTexture = null;
|
|
this.maxTexSize = null;
|
|
this.uniform1fCache = {};
|
|
this.uniform1iCache = {};
|
|
this.uniform2fCache = {};
|
|
this.uniform2fvCache = {};
|
|
this.uniform2ivCache = {};
|
|
this.uniform3fvCache = {};
|
|
this.uniform3ivCache = {};
|
|
|
|
this.mergeSettings(source.settings || settings);
|
|
}
|
|
|
|
initCanvas() {
|
|
if (typeof document !== 'undefined') {
|
|
const canvas = document.createElement('canvas');
|
|
canvas.width = 2;
|
|
canvas.height = 2;
|
|
return canvas;
|
|
} else if (typeof OffscreenCanvas !== 'undefined') {
|
|
return new OffscreenCanvas(0, 0);
|
|
}
|
|
}
|
|
|
|
initContext() {
|
|
const settings = {
|
|
alpha: false,
|
|
depth: false,
|
|
antialias: false
|
|
};
|
|
const context = this.canvas.getContext('webgl', settings) || this.canvas.getContext('experimental-webgl', settings);
|
|
return context;
|
|
}
|
|
|
|
initPlugins(settings) {
|
|
const pluginsToUse = [];
|
|
|
|
if (typeof this.source === 'string') {
|
|
for (let i = 0; i < plugins.length; i++) {
|
|
const plugin = plugins[i];
|
|
if (this.source.match(plugin.functionMatch)) {
|
|
pluginsToUse.push(plugin);
|
|
}
|
|
}
|
|
} else if (typeof this.source === 'object') {
|
|
if (settings.pluginNames) {
|
|
for (let i = 0; i < plugins.length; i++) {
|
|
const plugin = plugins[i];
|
|
const usePlugin = settings.pluginNames.some(pluginName => pluginName === plugin.name);
|
|
if (usePlugin) {
|
|
pluginsToUse.push(plugin);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return pluginsToUse;
|
|
}
|
|
|
|
initExtensions() {
|
|
this.extensions = {
|
|
OES_texture_float: this.context.getExtension('OES_texture_float'),
|
|
OES_texture_float_linear: this.context.getExtension('OES_texture_float_linear'),
|
|
OES_element_index_uint: this.context.getExtension('OES_element_index_uint'),
|
|
WEBGL_draw_buffers: this.context.getExtension('WEBGL_draw_buffers'),
|
|
};
|
|
}
|
|
|
|
validateSettings() {
|
|
if (this.skipValidate) {
|
|
this.texSize = utils.dimToTexSize({
|
|
floatTextures: this.floatTextures,
|
|
floatOutput: this.floatOutput
|
|
}, this.output, true);
|
|
return;
|
|
}
|
|
|
|
const features = this.constructor.features;
|
|
if (this.floatTextures === true && !features.isTextureFloat) {
|
|
throw new Error('Float textures are not supported');
|
|
} else if (this.floatOutput === true && this.floatOutputForce !== true && !features.isFloatRead) {
|
|
throw new Error('Float texture outputs are not supported');
|
|
} else if (this.floatTextures === undefined && features.isTextureFloat) {
|
|
this.floatTextures = true;
|
|
this.floatOutput = features.isFloatRead;
|
|
}
|
|
|
|
if (this.subKernels && this.subKernels.length > 0 && !this.extensions.WEBGL_draw_buffers) {
|
|
throw new Error('could not instantiate draw buffers extension');
|
|
}
|
|
|
|
if (this.fixIntegerDivisionAccuracy === null) {
|
|
this.fixIntegerDivisionAccuracy = !features.isIntegerDivisionAccurate;
|
|
} else if (this.fixIntegerDivisionAccuracy && features.isIntegerDivisionAccurate) {
|
|
this.fixIntegerDivisionAccuracy = false;
|
|
}
|
|
|
|
this.checkOutput();
|
|
|
|
if (!this.output || this.output.length === 0) {
|
|
if (arguments.length !== 1) {
|
|
throw new Error('Auto output only supported for kernels with only one input');
|
|
}
|
|
|
|
const argType = utils.getVariableType(arguments[0]);
|
|
if (argType === 'Array') {
|
|
this.output = utils.getDimensions(argType);
|
|
} else if (argType === 'NumberTexture' || argType === 'ArrayTexture(4)') {
|
|
this.output = arguments[0].output;
|
|
} else {
|
|
throw new Error('Auto output not supported for input type: ' + argType);
|
|
}
|
|
}
|
|
|
|
this.texSize = utils.dimToTexSize({
|
|
floatTextures: this.floatTextures,
|
|
floatOutput: this.floatOutput
|
|
}, this.output, true);
|
|
|
|
if (this.graphical) {
|
|
if (this.output.length !== 2) {
|
|
throw new Error('Output must have 2 dimensions on graphical mode');
|
|
}
|
|
|
|
if (this.floatOutput) {
|
|
this.floatOutput = false;
|
|
console.warn('Cannot use graphical mode and float output at the same time');
|
|
}
|
|
|
|
this.texSize = utils.clone(this.output);
|
|
} else if (this.floatOutput === undefined && features.isTextureFloat) {
|
|
this.floatOutput = true;
|
|
}
|
|
}
|
|
|
|
updateMaxTexSize() {
|
|
const texSize = this.texSize;
|
|
const canvas = this.canvas;
|
|
if (this.maxTexSize === null) {
|
|
let canvasIndex = canvases.indexOf(canvas);
|
|
if (canvasIndex === -1) {
|
|
canvasIndex = canvases.length;
|
|
canvases.push(canvas);
|
|
maxTexSizes[canvasIndex] = [texSize[0], texSize[1]];
|
|
}
|
|
this.maxTexSize = maxTexSizes[canvasIndex];
|
|
}
|
|
if (this.maxTexSize[0] < texSize[0]) {
|
|
this.maxTexSize[0] = texSize[0];
|
|
}
|
|
if (this.maxTexSize[1] < texSize[1]) {
|
|
this.maxTexSize[1] = texSize[1];
|
|
}
|
|
}
|
|
|
|
build() {
|
|
this.initExtensions();
|
|
this.validateSettings();
|
|
this.setupConstants();
|
|
this.setupArguments(arguments);
|
|
this.updateMaxTexSize();
|
|
const texSize = this.texSize;
|
|
const gl = this.context;
|
|
const canvas = this.canvas;
|
|
gl.enable(gl.SCISSOR_TEST);
|
|
gl.viewport(0, 0, this.maxTexSize[0], this.maxTexSize[1]);
|
|
canvas.width = this.maxTexSize[0];
|
|
canvas.height = this.maxTexSize[1];
|
|
const threadDim = this.threadDim = utils.clone(this.output);
|
|
while (threadDim.length < 3) {
|
|
threadDim.push(1);
|
|
}
|
|
|
|
const compiledVertexShader = this.getVertexShader(arguments);
|
|
const vertShader = gl.createShader(gl.VERTEX_SHADER);
|
|
gl.shaderSource(vertShader, compiledVertexShader);
|
|
gl.compileShader(vertShader);
|
|
this.vertShader = vertShader;
|
|
|
|
const compiledFragmentShader = this.getFragmentShader(arguments);
|
|
const fragShader = gl.createShader(gl.FRAGMENT_SHADER);
|
|
gl.shaderSource(fragShader, compiledFragmentShader);
|
|
gl.compileShader(fragShader);
|
|
this.fragShader = fragShader;
|
|
|
|
if (this.debug) {
|
|
console.log('GLSL Shader Output:');
|
|
console.log(compiledFragmentShader);
|
|
}
|
|
|
|
if (!gl.getShaderParameter(vertShader, gl.COMPILE_STATUS)) {
|
|
throw new Error('Error compiling vertex shader: ' + gl.getShaderInfoLog(vertShader));
|
|
}
|
|
if (!gl.getShaderParameter(fragShader, gl.COMPILE_STATUS)) {
|
|
throw new Error('Error compiling fragment shader: ' + gl.getShaderInfoLog(fragShader));
|
|
}
|
|
|
|
const program = this.program = gl.createProgram();
|
|
gl.attachShader(program, vertShader);
|
|
gl.attachShader(program, fragShader);
|
|
gl.linkProgram(program);
|
|
this.framebuffer = gl.createFramebuffer();
|
|
this.framebuffer.width = texSize[0];
|
|
this.framebuffer.height = texSize[1];
|
|
|
|
const vertices = new Float32Array([-1, -1,
|
|
1, -1, -1, 1,
|
|
1, 1
|
|
]);
|
|
const texCoords = new Float32Array([
|
|
0, 0,
|
|
1, 0,
|
|
0, 1,
|
|
1, 1
|
|
]);
|
|
|
|
const texCoordOffset = vertices.byteLength;
|
|
|
|
let buffer = this.buffer;
|
|
if (!buffer) {
|
|
buffer = this.buffer = gl.createBuffer();
|
|
gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
|
|
gl.bufferData(gl.ARRAY_BUFFER, vertices.byteLength + texCoords.byteLength, gl.STATIC_DRAW);
|
|
} else {
|
|
gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
|
|
}
|
|
|
|
gl.bufferSubData(gl.ARRAY_BUFFER, 0, vertices);
|
|
gl.bufferSubData(gl.ARRAY_BUFFER, texCoordOffset, texCoords);
|
|
|
|
const aPosLoc = gl.getAttribLocation(this.program, 'aPos');
|
|
gl.enableVertexAttribArray(aPosLoc);
|
|
gl.vertexAttribPointer(aPosLoc, 2, gl.FLOAT, false, 0, 0);
|
|
const aTexCoordLoc = gl.getAttribLocation(this.program, 'aTexCoord');
|
|
gl.enableVertexAttribArray(aTexCoordLoc);
|
|
gl.vertexAttribPointer(aTexCoordLoc, 2, gl.FLOAT, false, 0, texCoordOffset);
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
|
|
|
|
for (let p in this.constants) {
|
|
const value = this.constants[p];
|
|
const type = utils.getVariableType(value);
|
|
if (type === 'Float' || type === 'Integer') {
|
|
continue;
|
|
}
|
|
gl.useProgram(this.program);
|
|
this._addConstant(this.constants[p], type, p);
|
|
}
|
|
|
|
if (!this.immutable) {
|
|
this._setupOutputTexture();
|
|
if (
|
|
this.subKernels !== null &&
|
|
this.subKernels.length > 0
|
|
) {
|
|
this._setupSubOutputTextures(this.subKernels.length);
|
|
}
|
|
}
|
|
}
|
|
|
|
run() {
|
|
if (this.program === null) {
|
|
this.build.apply(this, arguments);
|
|
}
|
|
const argumentNames = this.argumentNames;
|
|
const argumentTypes = this.argumentTypes;
|
|
const texSize = this.texSize;
|
|
const gl = this.context;
|
|
|
|
gl.useProgram(this.program);
|
|
gl.scissor(0, 0, texSize[0], texSize[1]);
|
|
|
|
if (!this.hardcodeConstants) {
|
|
this.setUniform3iv('uOutputDim', this.threadDim);
|
|
this.setUniform2iv('uTexSize', texSize);
|
|
}
|
|
|
|
this.setUniform2f('ratio', texSize[0] / this.maxTexSize[0], texSize[1] / this.maxTexSize[1]);
|
|
|
|
this.argumentsLength = 0;
|
|
for (let texIndex = 0; texIndex < argumentNames.length; texIndex++) {
|
|
this._addArgument(arguments[texIndex], argumentTypes[texIndex], argumentNames[texIndex]);
|
|
}
|
|
|
|
if (this.plugins) {
|
|
for (let i = 0; i < this.plugins.length; i++) {
|
|
const plugin = this.plugins[i];
|
|
if (plugin.onBeforeRun) {
|
|
plugin.onBeforeRun(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.graphical) {
|
|
if (this.pipeline) {
|
|
gl.bindRenderbuffer(gl.RENDERBUFFER, null);
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
|
|
if (!this.outputTexture || this.immutable) {
|
|
this._setupOutputTexture();
|
|
}
|
|
gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
|
|
return new Texture(this.outputTexture, texSize, this.threadDim, this.output, this.context, 'ArrayTexture(4)');
|
|
}
|
|
gl.bindRenderbuffer(gl.RENDERBUFFER, null);
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
|
|
gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
|
|
return;
|
|
}
|
|
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
|
|
if (this.immutable) {
|
|
this._setupOutputTexture();
|
|
}
|
|
const outputTexture = this.outputTexture;
|
|
|
|
if (this.subKernels !== null) {
|
|
if (this.immutable) {
|
|
this.subKernelOutputTextures = [];
|
|
this._setupSubOutputTextures(this.subKernels.length);
|
|
}
|
|
this.extensions.WEBGL_draw_buffers.drawBuffersWEBGL(this.drawBuffersMap);
|
|
}
|
|
|
|
gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
|
|
|
|
if (this.subKernelOutputTextures !== null) {
|
|
if (this.subKernels !== null) {
|
|
const output = {
|
|
result: this.renderOutput(outputTexture),
|
|
};
|
|
for (let i = 0; i < this.subKernels.length; i++) {
|
|
output[this.subKernels[i].property] = new Texture(this.subKernelOutputTextures[i], texSize, this.threadDim, this.output, this.context);
|
|
}
|
|
return output;
|
|
}
|
|
}
|
|
|
|
return this.renderOutput(outputTexture);
|
|
}
|
|
|
|
renderOutput(outputTexture) {
|
|
const texSize = this.texSize;
|
|
const gl = this.context;
|
|
const threadDim = this.threadDim;
|
|
const output = this.output;
|
|
if (this.pipeline) {
|
|
return new Texture(outputTexture, texSize, this.threadDim, output, this.context);
|
|
} else {
|
|
let result;
|
|
if (this.floatOutput) {
|
|
const w = texSize[0];
|
|
const h = Math.ceil(texSize[1] / 4);
|
|
result = new Float32Array(w * h * 4);
|
|
gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, result);
|
|
} else {
|
|
const bytes = new Uint8Array(texSize[0] * texSize[1] * 4);
|
|
gl.readPixels(0, 0, texSize[0], texSize[1], gl.RGBA, gl.UNSIGNED_BYTE, bytes);
|
|
result = new Float32Array(bytes.buffer);
|
|
}
|
|
result = result.subarray(0, threadDim[0] * threadDim[1] * threadDim[2]);
|
|
|
|
if (output.length === 1) {
|
|
return result;
|
|
} else if (output.length === 2) {
|
|
return utils.splitArray(result, output[0]);
|
|
} else if (output.length === 3) {
|
|
const cube = utils.splitArray(result, output[0] * output[1]);
|
|
return cube.map(function(x) {
|
|
return utils.splitArray(x, output[0]);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
getOutputTexture() {
|
|
return this.outputTexture;
|
|
}
|
|
|
|
_setupOutputTexture() {
|
|
const gl = this.context;
|
|
const texSize = this.texSize;
|
|
const texture = this.outputTexture = this.context.createTexture();
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentNames.length);
|
|
gl.bindTexture(gl.TEXTURE_2D, texture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
if (this.floatOutput) {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texSize[0], texSize[1], 0, gl.RGBA, gl.FLOAT, null);
|
|
} else {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texSize[0], texSize[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
|
|
}
|
|
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
|
|
}
|
|
|
|
_setupSubOutputTextures(length) {
|
|
const gl = this.context;
|
|
const texSize = this.texSize;
|
|
const drawBuffersMap = this.drawBuffersMap = [gl.COLOR_ATTACHMENT0];
|
|
const textures = this.subKernelOutputTextures = [];
|
|
for (let i = 0; i < length; i++) {
|
|
const texture = this.context.createTexture();
|
|
textures.push(texture);
|
|
drawBuffersMap.push(gl.COLOR_ATTACHMENT0 + i + 1);
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentNames.length + i);
|
|
gl.bindTexture(gl.TEXTURE_2D, texture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
if (this.floatOutput) {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texSize[0], texSize[1], 0, gl.RGBA, gl.FLOAT, null);
|
|
} else {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texSize[0], texSize[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
|
|
}
|
|
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i + 1, gl.TEXTURE_2D, texture, 0);
|
|
}
|
|
}
|
|
|
|
getArgumentTexture(name) {
|
|
return this.getTextureCache(`ARGUMENT_${name}`);
|
|
}
|
|
|
|
getTextureCache(name) {
|
|
if (this.textureCache.hasOwnProperty(name)) {
|
|
return this.textureCache[name];
|
|
}
|
|
return this.textureCache[name] = this.context.createTexture();
|
|
}
|
|
|
|
detachTextureCache(name) {
|
|
delete this.textureCache[name];
|
|
}
|
|
|
|
setUniform1f(name, value) {
|
|
if (this.uniform1fCache.hasOwnProperty(name)) {
|
|
const cache = this.uniform1fCache[name];
|
|
if (value === cache) {
|
|
return;
|
|
}
|
|
}
|
|
this.uniform1fCache[name] = value;
|
|
const loc = this.getUniformLocation(name);
|
|
this.context.uniform1f(loc, value);
|
|
}
|
|
|
|
setUniform1i(name, value) {
|
|
if (this.uniform1iCache.hasOwnProperty(name)) {
|
|
const cache = this.uniform1iCache[name];
|
|
if (value === cache) {
|
|
return;
|
|
}
|
|
}
|
|
this.uniform1iCache[name] = value;
|
|
const loc = this.getUniformLocation(name);
|
|
this.context.uniform1i(loc, value);
|
|
}
|
|
|
|
setUniform2f(name, value1, value2) {
|
|
if (this.uniform2fCache.hasOwnProperty(name)) {
|
|
const cache = this.uniform2fCache[name];
|
|
if (
|
|
value1 === cache[0] &&
|
|
value2 === cache[1]
|
|
) {
|
|
return;
|
|
}
|
|
}
|
|
this.uniform2fCache[name] = [value1, value2];
|
|
const loc = this.getUniformLocation(name);
|
|
this.context.uniform2f(loc, value1, value2);
|
|
}
|
|
|
|
setUniform2fv(name, value) {
|
|
if (this.uniform2fvCache.hasOwnProperty(name)) {
|
|
const cache = this.uniform2fvCache[name];
|
|
if (
|
|
value[0] === cache[0] &&
|
|
value[1] === cache[1]
|
|
) {
|
|
return;
|
|
}
|
|
}
|
|
this.uniform2fvCache[name] = value;
|
|
const loc = this.getUniformLocation(name);
|
|
this.context.uniform2fv(loc, value);
|
|
}
|
|
|
|
setUniform2iv(name, value) {
|
|
if (this.uniform2ivCache.hasOwnProperty(name)) {
|
|
const cache = this.uniform2ivCache[name];
|
|
if (
|
|
value[0] === cache[0] &&
|
|
value[1] === cache[1]
|
|
) {
|
|
return;
|
|
}
|
|
}
|
|
this.uniform2ivCache[name] = value;
|
|
const loc = this.getUniformLocation(name);
|
|
this.context.uniform2iv(loc, value);
|
|
}
|
|
|
|
setUniform3fv(name, value) {
|
|
if (this.uniform3fvCache.hasOwnProperty(name)) {
|
|
const cache = this.uniform3fvCache[name];
|
|
if (
|
|
value[0] === cache[0] &&
|
|
value[1] === cache[1] &&
|
|
value[2] === cache[2]
|
|
) {
|
|
return;
|
|
}
|
|
}
|
|
this.uniform3fvCache[name] = value;
|
|
const loc = this.getUniformLocation(name);
|
|
this.context.uniform3fv(loc, value);
|
|
}
|
|
|
|
setUniform3iv(name, value) {
|
|
if (this.uniform3ivCache.hasOwnProperty(name)) {
|
|
const cache = this.uniform3ivCache[name];
|
|
if (
|
|
value[0] === cache[0] &&
|
|
value[1] === cache[1] &&
|
|
value[2] === cache[2]
|
|
) {
|
|
return;
|
|
}
|
|
}
|
|
this.uniform3ivCache[name] = value;
|
|
const loc = this.getUniformLocation(name);
|
|
this.context.uniform3iv(loc, value);
|
|
}
|
|
|
|
getUniformLocation(name) {
|
|
if (this.programUniformLocationCache.hasOwnProperty(name)) {
|
|
return this.programUniformLocationCache[name];
|
|
}
|
|
return this.programUniformLocationCache[name] = this.context.getUniformLocation(this.program, name);
|
|
}
|
|
|
|
_getFragShaderArtifactMap(args) {
|
|
return {
|
|
HEADER: this._getHeaderString(),
|
|
LOOP_MAX: this._getLoopMaxString(),
|
|
PLUGINS: this._getPluginsString(),
|
|
CONSTANTS: this._getConstantsString(),
|
|
DECODE32_ENDIANNESS: this._getDecode32EndiannessString(),
|
|
ENCODE32_ENDIANNESS: this._getEncode32EndiannessString(),
|
|
DIVIDE_WITH_INTEGER_CHECK: this._getDivideWithIntegerCheckString(),
|
|
GET_WRAPAROUND: this._getGetWraparoundString(),
|
|
GET_TEXTURE_CHANNEL: this._getGetTextureChannelString(),
|
|
GET_TEXTURE_INDEX: this._getGetTextureIndexString(),
|
|
GET_RESULT: this._getGetResultString(),
|
|
MAIN_CONSTANTS: this._getMainConstantsString(),
|
|
MAIN_ARGUMENTS: this._getMainArgumentsString(args),
|
|
KERNEL: this._getKernelString(),
|
|
MAIN_RESULT: this._getMainResultString()
|
|
};
|
|
}
|
|
|
|
_addArgument(value, type, name) {
|
|
const gl = this.context;
|
|
const argumentTexture = this.getArgumentTexture(name);
|
|
if (value instanceof Texture) {
|
|
type = value.type;
|
|
}
|
|
switch (type) {
|
|
case 'Array':
|
|
case 'Array(2)':
|
|
case 'Array(3)':
|
|
case 'Array(4)':
|
|
case 'Array2D':
|
|
case 'Array3D':
|
|
{
|
|
const dim = utils.getDimensions(value, true);
|
|
const size = utils.dimToTexSize({
|
|
floatTextures: this.floatTextures,
|
|
floatOutput: this.floatOutput
|
|
}, dim);
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
|
|
let length = size[0] * size[1];
|
|
|
|
const {
|
|
valuesFlat,
|
|
bitRatio
|
|
} = this._formatArrayTransfer(value, length);
|
|
|
|
let buffer;
|
|
if (this.floatTextures) {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0], size[1], 0, gl.RGBA, gl.FLOAT, valuesFlat);
|
|
} else {
|
|
buffer = new Uint8Array(valuesFlat.buffer);
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
|
|
}
|
|
|
|
if (!this.hardcodeConstants) {
|
|
this.setUniform3iv(`user_${name}Dim`, dim);
|
|
this.setUniform2iv(`user_${name}Size`, size);
|
|
}
|
|
this.setUniform1i(`user_${name}BitRatio`, bitRatio);
|
|
this.setUniform1i(`user_${name}`, this.argumentsLength);
|
|
break;
|
|
}
|
|
case 'Integer':
|
|
case 'Float':
|
|
case 'Number':
|
|
{
|
|
this.setUniform1f(`user_${name}`, value);
|
|
break;
|
|
}
|
|
case 'Input':
|
|
{
|
|
const input = value;
|
|
const dim = input.size;
|
|
const size = utils.dimToTexSize({
|
|
floatTextures: this.floatTextures,
|
|
floatOutput: this.floatOutput
|
|
}, dim);
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
|
|
let length = size[0] * size[1];
|
|
|
|
const {
|
|
valuesFlat,
|
|
bitRatio
|
|
} = this._formatArrayTransfer(value.value, length);
|
|
|
|
if (this.floatTextures) {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0], size[1], 0, gl.RGBA, gl.FLOAT, input);
|
|
} else {
|
|
const buffer = new Uint8Array(valuesFlat.buffer);
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
|
|
}
|
|
|
|
if (!this.hardcodeConstants) {
|
|
this.setUniform3iv(`user_${name}Dim`, dim);
|
|
this.setUniform2iv(`user_${name}Size`, size);
|
|
}
|
|
this.setUniform1i(`user_${name}BitRatio`, bitRatio);
|
|
this.setUniform1i(`user_${name}`, this.argumentsLength);
|
|
break;
|
|
}
|
|
case 'HTMLImage':
|
|
{
|
|
const inputImage = value;
|
|
const dim = [inputImage.width, inputImage.height, 1];
|
|
const size = [inputImage.width, inputImage.height];
|
|
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
|
|
const mipLevel = 0;
|
|
const internalFormat = gl.RGBA;
|
|
const srcFormat = gl.RGBA;
|
|
const srcType = gl.UNSIGNED_BYTE;
|
|
gl.texImage2D(gl.TEXTURE_2D,
|
|
mipLevel,
|
|
internalFormat,
|
|
srcFormat,
|
|
srcType,
|
|
inputImage);
|
|
this.setUniform3iv(`user_${name}Dim`, dim);
|
|
this.setUniform2iv(`user_${name}Size`, size);
|
|
this.setUniform1i(`user_${name}`, this.argumentsLength);
|
|
break;
|
|
}
|
|
case 'ArrayTexture(4)':
|
|
case 'NumberTexture':
|
|
{
|
|
const inputTexture = value;
|
|
if (inputTexture.context !== this.context) {
|
|
throw new Error(`argument ${ name} (${ type }) must be from same context`);
|
|
}
|
|
const dim = inputTexture.dimensions;
|
|
const size = inputTexture.size;
|
|
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, inputTexture.texture);
|
|
|
|
this.setUniform3iv(`user_${name}Dim`, dim);
|
|
this.setUniform2iv(`user_${name}Size`, size);
|
|
this.setUniform1i(`user_${name}BitRatio`, 1);
|
|
this.setUniform1i(`user_${name}`, this.argumentsLength);
|
|
break;
|
|
}
|
|
default:
|
|
throw new Error('Input type not supported: ' + value);
|
|
}
|
|
this.argumentsLength++;
|
|
}
|
|
|
|
_addConstant(value, type, name) {
|
|
const gl = this.context;
|
|
const argumentTexture = this.getArgumentTexture(name);
|
|
if (value instanceof Texture) {
|
|
type = value.type;
|
|
}
|
|
switch (type) {
|
|
case 'Array':
|
|
{
|
|
const dim = utils.getDimensions(value, true);
|
|
const size = utils.dimToTexSize({
|
|
floatTextures: this.floatTextures,
|
|
floatOutput: this.floatOutput
|
|
}, dim);
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
|
|
let length = size[0] * size[1];
|
|
|
|
const {
|
|
valuesFlat,
|
|
bitRatio
|
|
} = this._formatArrayTransfer(value, length);
|
|
|
|
let buffer;
|
|
if (this.floatTextures) {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0], size[1], 0, gl.RGBA, gl.FLOAT, valuesFlat);
|
|
} else {
|
|
buffer = new Uint8Array(valuesFlat.buffer);
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
|
|
}
|
|
|
|
if (!this.hardcodeConstants) {
|
|
this.setUniform3iv(`constants_${name}Dim`, dim);
|
|
this.setUniform2iv(`constants_${name}Size`, size);
|
|
}
|
|
this.setUniform1i(`constants_${name}BitRatio`, bitRatio);
|
|
this.setUniform1i(`constants_${name}`, this.constantsLength);
|
|
break;
|
|
}
|
|
case 'Input':
|
|
{
|
|
const input = value;
|
|
const dim = input.size;
|
|
const size = utils.dimToTexSize({
|
|
floatTextures: this.floatTextures,
|
|
floatOutput: this.floatOutput
|
|
}, dim);
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
|
|
let length = size[0] * size[1];
|
|
const {
|
|
valuesFlat,
|
|
bitRatio
|
|
} = this._formatArrayTransfer(value.value, length);
|
|
|
|
if (this.floatTextures) {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0], size[1], 0, gl.RGBA, gl.FLOAT, inputArray);
|
|
} else {
|
|
const buffer = new Uint8Array(valuesFlat.buffer);
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
|
|
}
|
|
|
|
if (!this.hardcodeConstants) {
|
|
this.setUniform3iv(`constants_${name}Dim`, dim);
|
|
this.setUniform2iv(`constants_${name}Size`, size);
|
|
}
|
|
this.setUniform1i(`constants_${name}BitRatio`, bitRatio);
|
|
this.setUniform1i(`constants_${name}`, this.constantsLength);
|
|
break;
|
|
}
|
|
case 'HTMLImage':
|
|
{
|
|
const inputImage = value;
|
|
const dim = [inputImage.width, inputImage.height, 1];
|
|
const size = [inputImage.width, inputImage.height];
|
|
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
|
|
const mipLevel = 0;
|
|
const internalFormat = gl.RGBA;
|
|
const srcFormat = gl.RGBA;
|
|
const srcType = gl.UNSIGNED_BYTE;
|
|
gl.texImage2D(gl.TEXTURE_2D,
|
|
mipLevel,
|
|
internalFormat,
|
|
srcFormat,
|
|
srcType,
|
|
inputImage);
|
|
this.setUniform3iv(`constants_${name}Dim`, dim);
|
|
this.setUniform2iv(`constants_${name}Size`, size);
|
|
this.setUniform1i(`constants_${name}`, this.constantsLength);
|
|
break;
|
|
}
|
|
case 'ArrayTexture(4)':
|
|
case 'NumberTexture':
|
|
{
|
|
const inputTexture = value;
|
|
if (inputTexture.context !== this.context) {
|
|
throw new Error(`argument ${ name} (${ type }) must be from same context`);
|
|
}
|
|
const dim = inputTexture.dimensions;
|
|
const size = inputTexture.size;
|
|
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, inputTexture.texture);
|
|
this.setUniform3iv(`constants_${name}Dim`, dim);
|
|
this.setUniform2iv(`constants_${name}Size`, size);
|
|
this.setUniform1i(`constants_${name}BitRatio`, 1);
|
|
this.setUniform1i(`constants_${name}`, this.constantsLength);
|
|
break;
|
|
}
|
|
case 'Integer':
|
|
case 'Float':
|
|
default:
|
|
throw new Error('Input type not supported: ' + value);
|
|
}
|
|
this.constantsLength++;
|
|
}
|
|
|
|
_formatArrayTransfer(value, length) {
|
|
let bitRatio = 1;
|
|
let valuesFlat = value;
|
|
if (utils.isArray(value[0]) || this.floatTextures) {
|
|
valuesFlat = new Float32Array(length);
|
|
utils.flattenTo(value, valuesFlat);
|
|
} else {
|
|
|
|
switch (value.constructor) {
|
|
case Uint8Array:
|
|
case Int8Array:
|
|
bitRatio = 4;
|
|
break;
|
|
case Uint16Array:
|
|
case Int16Array:
|
|
bitRatio = 2;
|
|
case Float32Array:
|
|
case Int32Array:
|
|
break;
|
|
|
|
default:
|
|
valuesFlat = new Float32Array(length);
|
|
utils.flattenTo(value, valuesFlat);
|
|
}
|
|
}
|
|
return {
|
|
bitRatio,
|
|
valuesFlat
|
|
};
|
|
}
|
|
|
|
_getHeaderString() {
|
|
return (
|
|
this.subKernels !== null ?
|
|
'#extension GL_EXT_draw_buffers : require\n' :
|
|
''
|
|
);
|
|
}
|
|
|
|
_getLoopMaxString() {
|
|
return (
|
|
this.loopMaxIterations ?
|
|
` ${parseInt(this.loopMaxIterations)};\n` :
|
|
' 1000;\n'
|
|
);
|
|
}
|
|
|
|
_getPluginsString() {
|
|
if (!this.plugins) return '\n';
|
|
return this.plugins.map(plugin => plugin.source && this.source.match(plugin.functionMatch) ? plugin.source : '').join('\n');
|
|
}
|
|
|
|
_getConstantsString() {
|
|
const result = [];
|
|
const threadDim = this.threadDim;
|
|
const texSize = this.texSize;
|
|
if (this.hardcodeConstants) {
|
|
result.push(
|
|
`ivec3 uOutputDim = ivec3(${threadDim[0]}, ${threadDim[1]}, ${threadDim[2]})`,
|
|
`ivec2 uTexSize = ivec2(${texSize[0]}, ${texSize[1]})`
|
|
);
|
|
} else {
|
|
result.push(
|
|
'uniform ivec3 uOutputDim',
|
|
'uniform ivec2 uTexSize'
|
|
);
|
|
}
|
|
|
|
return this._linesToString(result);
|
|
}
|
|
|
|
_getTextureCoordinate() {
|
|
const subKernels = this.subKernels;
|
|
if (subKernels === null || subKernels.length < 1) {
|
|
return 'varying vec2 vTexCoord;\n';
|
|
} else {
|
|
return 'out vec2 vTexCoord;\n';
|
|
}
|
|
}
|
|
|
|
_getDecode32EndiannessString() {
|
|
return (
|
|
this.endianness === 'LE' ?
|
|
'' :
|
|
' rgba.rgba = rgba.abgr;\n'
|
|
);
|
|
}
|
|
|
|
_getEncode32EndiannessString() {
|
|
return (
|
|
this.endianness === 'LE' ?
|
|
'' :
|
|
' rgba.rgba = rgba.abgr;\n'
|
|
);
|
|
}
|
|
|
|
_getDivideWithIntegerCheckString() {
|
|
return this.fixIntegerDivisionAccuracy ?
|
|
`float div_with_int_check(float x, float y) {
|
|
if (floor(x) == x && floor(y) == y && integerMod(x, y) == 0.0) {
|
|
return float(int(x)/int(y));
|
|
}
|
|
return x / y;
|
|
}` :
|
|
'';
|
|
}
|
|
|
|
_getGetWraparoundString() {
|
|
return (
|
|
this.wraparound ?
|
|
' xyz = mod(xyz, texDim);\n' :
|
|
''
|
|
);
|
|
}
|
|
|
|
_getGetTextureChannelString() {
|
|
if (!this.floatTextures) return '';
|
|
|
|
return this._linesToString([
|
|
' int channel = integerMod(index, 4)',
|
|
' index = index / 4'
|
|
]);
|
|
}
|
|
|
|
_getGetTextureIndexString() {
|
|
return (
|
|
this.floatTextures ?
|
|
' index = index / 4;\n' :
|
|
''
|
|
);
|
|
}
|
|
|
|
_getGetResultString() {
|
|
if (!this.floatTextures) {
|
|
return ' return decode(texel, x, bitRatio);';
|
|
}
|
|
return this._linesToString([
|
|
' if (channel == 0) return texel.r',
|
|
' if (channel == 1) return texel.g',
|
|
' if (channel == 2) return texel.b',
|
|
' if (channel == 3) return texel.a'
|
|
]);
|
|
}
|
|
|
|
_getMainArgumentsString(args) {
|
|
const result = [];
|
|
const argumentTypes = this.argumentTypes;
|
|
const argumentNames = this.argumentNames;
|
|
for (let i = 0; i < argumentNames.length; i++) {
|
|
const value = args[i];
|
|
const name = argumentNames[i];
|
|
const type = argumentTypes[i];
|
|
if (this.hardcodeConstants) {
|
|
if (type === 'Array' || type === 'NumberTexture' || type === 'ArrayTexture(4)') {
|
|
const dim = utils.getDimensions(value, true);
|
|
const size = utils.dimToTexSize({
|
|
floatTextures: this.floatTextures,
|
|
floatOutput: this.floatOutput
|
|
}, dim);
|
|
|
|
result.push(
|
|
`uniform sampler2D user_${name}`,
|
|
`ivec2 user_${name}Size = ivec2(${size[0]}, ${size[1]})`,
|
|
`ivec3 user_${name}Dim = ivec3(${dim[0]}, ${dim[1]}, ${dim[2]})`,
|
|
`uniform int user_${name}BitRatio`
|
|
);
|
|
} else if (type === 'Integer') {
|
|
result.push(`float user_${name} = ${value}.0`);
|
|
} else if (type === 'Float') {
|
|
result.push(`float user_${name} = ${value}`);
|
|
}
|
|
} else {
|
|
if (type === 'Array' || type === 'NumberTexture' || type === 'ArrayTexture(4)' || type === 'Input' || type === 'HTMLImage') {
|
|
result.push(
|
|
`uniform sampler2D user_${name}`,
|
|
`uniform ivec2 user_${name}Size`,
|
|
`uniform ivec3 user_${name}Dim`
|
|
);
|
|
if (type !== 'HTMLImage') {
|
|
result.push(`uniform int user_${name}BitRatio`)
|
|
}
|
|
} else if (type === 'Integer' || type === 'Float' || type === 'Number') {
|
|
result.push(`uniform float user_${name}`);
|
|
} else {
|
|
throw new Error(`Param type ${type} not supported in WebGL`);
|
|
}
|
|
}
|
|
}
|
|
return this._linesToString(result);
|
|
}
|
|
|
|
_getMainConstantsString() {
|
|
const result = [];
|
|
if (this.constants) {
|
|
for (let name in this.constants) {
|
|
if (!this.constants.hasOwnProperty(name)) continue;
|
|
let value = this.constants[name];
|
|
let type = utils.getVariableType(value);
|
|
switch (type) {
|
|
case 'Integer':
|
|
result.push('const int constants_' + name + ' = ' + parseInt(value));
|
|
break;
|
|
case 'Float':
|
|
result.push('const float constants_' + name + ' = ' + parseFloat(value));
|
|
break;
|
|
case 'Array':
|
|
case 'Input':
|
|
case 'HTMLImage':
|
|
case 'NumberTexture':
|
|
case 'ArrayTexture(4)':
|
|
result.push(
|
|
`uniform sampler2D constants_${name}`,
|
|
`uniform ivec2 constants_${name}Size`,
|
|
`uniform ivec3 constants_${name}Dim`,
|
|
`uniform int constants_${name}BitRatio`
|
|
);
|
|
break;
|
|
default:
|
|
throw new Error(`Unsupported constant ${name} type ${type}`);
|
|
}
|
|
}
|
|
}
|
|
return this._linesToString(result);
|
|
}
|
|
|
|
_getKernelString() {
|
|
const result = [];
|
|
const subKernels = this.subKernels;
|
|
if (subKernels !== null) {
|
|
result.push('float kernelResult = 0.0');
|
|
for (let i = 0; i < subKernels.length; i++) {
|
|
result.push(
|
|
`float subKernelResult_${subKernels[i].name} = 0.0`
|
|
);
|
|
}
|
|
} else {
|
|
result.push('float kernelResult = 0.0');
|
|
}
|
|
|
|
const functionBuilder = FunctionBuilder.fromKernel(this, WebGLFunctionNode, {
|
|
fixIntegerDivisionAccuracy: this.fixIntegerDivisionAccuracy
|
|
});
|
|
|
|
return this._linesToString(result) + functionBuilder.getPrototypeString('kernel');
|
|
}
|
|
|
|
_getMainResultString() {
|
|
const subKernels = this.subKernels;
|
|
const result = [];
|
|
|
|
if (this.floatOutput) {
|
|
result.push(' index *= 4');
|
|
}
|
|
|
|
if (this.graphical) {
|
|
result.push(
|
|
' threadId = indexTo3D(index, uOutputDim)',
|
|
' kernel()',
|
|
' gl_FragColor = actualColor'
|
|
);
|
|
} else if (this.floatOutput) {
|
|
const channels = ['r', 'g', 'b', 'a'];
|
|
|
|
for (let i = 0; i < channels.length; ++i) {
|
|
result.push(' threadId = indexTo3D(index, uOutputDim)');
|
|
result.push(' kernel()');
|
|
|
|
if (subKernels) {
|
|
result.push(` gl_FragData[0].${channels[i]} = kernelResult`);
|
|
|
|
for (let j = 0; j < subKernels.length; ++j) {
|
|
result.push(` gl_FragData[${j + 1}].${channels[i]} = subKernelResult_${subKernels[j].name}`);
|
|
}
|
|
} else {
|
|
result.push(` gl_FragColor.${channels[i]} = kernelResult`);
|
|
}
|
|
|
|
if (i < channels.length - 1) {
|
|
result.push(' index += 1');
|
|
}
|
|
}
|
|
} else if (subKernels !== null) {
|
|
result.push(' threadId = indexTo3D(index, uOutputDim)');
|
|
result.push(' kernel()');
|
|
result.push(' gl_FragData[0] = encode32(kernelResult)');
|
|
for (let i = 0; i < subKernels.length; i++) {
|
|
result.push(` gl_FragData[${i + 1}] = encode32(subKernelResult_${subKernels[i].name})`);
|
|
}
|
|
} else {
|
|
result.push(
|
|
' threadId = indexTo3D(index, uOutputDim)',
|
|
' kernel()',
|
|
' gl_FragColor = encode32(kernelResult)'
|
|
);
|
|
}
|
|
|
|
return this._linesToString(result);
|
|
}
|
|
|
|
_linesToString(lines) {
|
|
if (lines.length > 0) {
|
|
return lines.join(';\n') + ';\n';
|
|
} else {
|
|
return '\n';
|
|
}
|
|
}
|
|
|
|
replaceArtifacts(src, map) {
|
|
return src.replace(/[ ]*__([A-Z]+[0-9]*([_]?[A-Z])*)__;\n/g, (match, artifact) => {
|
|
if (map.hasOwnProperty(artifact)) {
|
|
return map[artifact];
|
|
}
|
|
throw `unhandled artifact ${artifact}`;
|
|
});
|
|
}
|
|
|
|
getFragmentShader(args) {
|
|
if (this.compiledFragmentShader !== null) {
|
|
return this.compiledFragmentShader;
|
|
}
|
|
return this.compiledFragmentShader = this.replaceArtifacts(this.constructor.fragmentShader, this._getFragShaderArtifactMap(args));
|
|
}
|
|
|
|
getVertexShader(args) {
|
|
if (this.compiledVertexShader !== null) {
|
|
return this.compiledVertexShader;
|
|
}
|
|
return this.compiledVertexShader = this.constructor.vertexShader;
|
|
}
|
|
|
|
toString() {
|
|
return webGLKernelString(this);
|
|
}
|
|
|
|
destroy(removeCanvasReferences) {
|
|
if (this.outputTexture) {
|
|
this.context.deleteTexture(this.outputTexture);
|
|
}
|
|
if (this.buffer) {
|
|
this.context.deleteBuffer(this.buffer);
|
|
}
|
|
if (this.framebuffer) {
|
|
this.context.deleteFramebuffer(this.framebuffer);
|
|
}
|
|
if (this.vertShader) {
|
|
this.context.deleteShader(this.vertShader);
|
|
}
|
|
if (this.fragShader) {
|
|
this.context.deleteShader(this.fragShader);
|
|
}
|
|
if (this.program) {
|
|
this.context.deleteProgram(this.program);
|
|
}
|
|
|
|
const keys = Object.keys(this.textureCache);
|
|
|
|
for (let i = 0; i < keys.length; i++) {
|
|
const name = keys[i];
|
|
this.context.deleteTexture(this.textureCache[name]);
|
|
}
|
|
|
|
if (this.subKernelOutputTextures) {
|
|
for (let i = 0; i < this.subKernelOutputTextures.length; i++) {
|
|
this.context.deleteTexture(this.subKernelOutputTextures[i]);
|
|
}
|
|
}
|
|
if (removeCanvasReferences) {
|
|
const idx = canvases.indexOf(this.canvas);
|
|
if (idx >= 0) {
|
|
canvases[idx] = null;
|
|
maxTexSizes[idx] = null;
|
|
}
|
|
}
|
|
this.destroyExtensions();
|
|
delete this.context;
|
|
delete this.canvas;
|
|
}
|
|
|
|
destroyExtensions() {
|
|
this.extensions.OES_texture_float = null;
|
|
this.extensions.OES_texture_float_linear = null;
|
|
this.extensions.OES_element_index_uint = null;
|
|
}
|
|
|
|
static destroyContext(context) {
|
|
const extension = context.getExtension('WEBGL_lose_context');
|
|
if (extension) {
|
|
extension.loseContext();
|
|
}
|
|
}
|
|
|
|
toJSON() {
|
|
const json = super.toJSON();
|
|
json.functionNodes = FunctionBuilder.fromKernel(this, WebGLFunctionNode).toJSON();
|
|
return json;
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
WebGLKernel
|
|
};
|
|
},{"../../plugins/triangle-noise":27,"../../texture":28,"../../utils":29,"../function-builder":8,"../gl-kernel":10,"./fragment-shader":13,"./function-node":14,"./kernel-string":15,"./vertex-shader":17}],17:[function(require,module,exports){
|
|
const vertexShader = `precision highp float;
|
|
precision highp int;
|
|
precision highp sampler2D;
|
|
|
|
attribute vec2 aPos;
|
|
attribute vec2 aTexCoord;
|
|
|
|
varying vec2 vTexCoord;
|
|
uniform vec2 ratio;
|
|
|
|
void main(void) {
|
|
gl_Position = vec4((aPos + vec2(1)) * ratio + vec2(-1), 0, 1);
|
|
vTexCoord = aTexCoord;
|
|
}`;
|
|
|
|
module.exports = {
|
|
vertexShader
|
|
};
|
|
},{}],18:[function(require,module,exports){
|
|
const fragmentShader = `#version 300 es
|
|
__HEADER__;
|
|
precision highp float;
|
|
precision highp int;
|
|
precision highp sampler2D;
|
|
|
|
const int LOOP_MAX = __LOOP_MAX__;
|
|
|
|
__PLUGINS__;
|
|
__CONSTANTS__;
|
|
|
|
in vec2 vTexCoord;
|
|
|
|
vec2 integerMod(vec2 x, float y) {
|
|
vec2 res = floor(mod(x, y));
|
|
return res * step(1.0 - floor(y), -res);
|
|
}
|
|
|
|
vec3 integerMod(vec3 x, float y) {
|
|
vec3 res = floor(mod(x, y));
|
|
return res * step(1.0 - floor(y), -res);
|
|
}
|
|
|
|
vec4 integerMod(vec4 x, vec4 y) {
|
|
vec4 res = floor(mod(x, y));
|
|
return res * step(1.0 - floor(y), -res);
|
|
}
|
|
|
|
float integerMod(float x, float y) {
|
|
float res = floor(mod(x, y));
|
|
return res * (res > floor(y) - 1.0 ? 0.0 : 1.0);
|
|
}
|
|
|
|
int integerMod(int x, int y) {
|
|
return x - (y * int(x/y));
|
|
}
|
|
|
|
__DIVIDE_WITH_INTEGER_CHECK__;
|
|
|
|
// Here be dragons!
|
|
// DO NOT OPTIMIZE THIS CODE
|
|
// YOU WILL BREAK SOMETHING ON SOMEBODY\'S MACHINE
|
|
// LEAVE IT AS IT IS, LEST YOU WASTE YOUR OWN TIME
|
|
const vec2 MAGIC_VEC = vec2(1.0, -256.0);
|
|
const vec4 SCALE_FACTOR = vec4(1.0, 256.0, 65536.0, 0.0);
|
|
const vec4 SCALE_FACTOR_INV = vec4(1.0, 0.00390625, 0.0000152587890625, 0.0); // 1, 1/256, 1/65536
|
|
float decode32(vec4 rgba) {
|
|
__DECODE32_ENDIANNESS__;
|
|
rgba *= 255.0;
|
|
vec2 gte128;
|
|
gte128.x = rgba.b >= 128.0 ? 1.0 : 0.0;
|
|
gte128.y = rgba.a >= 128.0 ? 1.0 : 0.0;
|
|
float exponent = 2.0 * rgba.a - 127.0 + dot(gte128, MAGIC_VEC);
|
|
float res = exp2(round(exponent));
|
|
rgba.b = rgba.b - 128.0 * gte128.x;
|
|
res = dot(rgba, SCALE_FACTOR) * exp2(round(exponent-23.0)) + res;
|
|
res *= gte128.y * -2.0 + 1.0;
|
|
return res;
|
|
}
|
|
|
|
vec4 encode32(float f) {
|
|
float F = abs(f);
|
|
float sign = f < 0.0 ? 1.0 : 0.0;
|
|
float exponent = floor(log2(F));
|
|
float mantissa = (exp2(-exponent) * F);
|
|
// exponent += floor(log2(mantissa));
|
|
vec4 rgba = vec4(F * exp2(23.0-exponent)) * SCALE_FACTOR_INV;
|
|
rgba.rg = integerMod(rgba.rg, 256.0);
|
|
rgba.b = integerMod(rgba.b, 128.0);
|
|
rgba.a = exponent*0.5 + 63.5;
|
|
rgba.ba += vec2(integerMod(exponent+127.0, 2.0), sign) * 128.0;
|
|
rgba = floor(rgba);
|
|
rgba *= 0.003921569; // 1/255
|
|
__ENCODE32_ENDIANNESS__;
|
|
return rgba;
|
|
}
|
|
// Dragons end here
|
|
|
|
float decode(vec4 rgba, int x, int bitRatio) {
|
|
if (bitRatio == 1) {
|
|
return decode32(rgba);
|
|
}
|
|
__DECODE32_ENDIANNESS__;
|
|
int channel = integerMod(x, bitRatio);
|
|
if (bitRatio == 4) {
|
|
return rgba[channel] * 255.0;
|
|
}
|
|
else {
|
|
return rgba[channel*2] * 255.0 + rgba[channel*2 + 1] * 65280.0;
|
|
}
|
|
}
|
|
|
|
int index;
|
|
ivec3 threadId;
|
|
|
|
ivec3 indexTo3D(int idx, ivec3 texDim) {
|
|
int z = int(idx / (texDim.x * texDim.y));
|
|
idx -= z * int(texDim.x * texDim.y);
|
|
int y = int(idx / texDim.x);
|
|
int x = int(integerMod(idx, texDim.x));
|
|
return ivec3(x, y, z);
|
|
}
|
|
|
|
float get(sampler2D tex, ivec2 texSize, ivec3 texDim, int bitRatio, int z, int y, int x) {
|
|
ivec3 xyz = ivec3(x, y, z);
|
|
__GET_WRAPAROUND__;
|
|
int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);
|
|
__GET_TEXTURE_CHANNEL__;
|
|
int w = texSize.x;
|
|
vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;
|
|
__GET_TEXTURE_INDEX__;
|
|
vec4 texel = texture(tex, st / vec2(texSize));
|
|
__GET_RESULT__;
|
|
}
|
|
|
|
vec4 getImage2D(sampler2D tex, ivec2 texSize, ivec3 texDim, int z, int y, int x) {
|
|
ivec3 xyz = ivec3(x, y, z);
|
|
__GET_WRAPAROUND__;
|
|
int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);
|
|
__GET_TEXTURE_CHANNEL__;
|
|
int w = texSize.x;
|
|
vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;
|
|
__GET_TEXTURE_INDEX__;
|
|
return texture(tex, st / vec2(texSize));
|
|
}
|
|
|
|
vec4 getImage3D(sampler2DArray tex, ivec2 texSize, ivec3 texDim, int z, int y, int x) {
|
|
ivec3 xyz = ivec3(x, y, z);
|
|
__GET_WRAPAROUND__;
|
|
int index = xyz.x + texDim.x * (xyz.y + texDim.y * xyz.z);
|
|
__GET_TEXTURE_CHANNEL__;
|
|
int w = texSize.x;
|
|
vec2 st = vec2(float(integerMod(index, w)), float(index / w)) + 0.5;
|
|
__GET_TEXTURE_INDEX__;
|
|
return texture(tex, vec3(st / vec2(texSize), z));
|
|
}
|
|
|
|
vec4 actualColor;
|
|
void color(float r, float g, float b, float a) {
|
|
actualColor = vec4(r,g,b,a);
|
|
}
|
|
|
|
void color(float r, float g, float b) {
|
|
color(r,g,b,1.0);
|
|
}
|
|
|
|
__MAIN_CONSTANTS__;
|
|
__MAIN_ARGUMENTS__;
|
|
__KERNEL__;
|
|
|
|
void main(void) {
|
|
index = int(vTexCoord.s * float(uTexSize.x)) + int(vTexCoord.t * float(uTexSize.y)) * uTexSize.x;
|
|
__MAIN_RESULT__;
|
|
}`;
|
|
|
|
module.exports = {
|
|
fragmentShader
|
|
};
|
|
},{}],19:[function(require,module,exports){
|
|
const {
|
|
WebGLFunctionNode
|
|
} = require('../web-gl/function-node');
|
|
|
|
class WebGL2FunctionNode extends WebGLFunctionNode {
|
|
|
|
astIdentifierExpression(idtNode, retArr) {
|
|
if (idtNode.type !== 'Identifier') {
|
|
throw this.astErrorOutput(
|
|
'IdentifierExpression - not an Identifier',
|
|
idtNode
|
|
);
|
|
}
|
|
|
|
switch (idtNode.name) {
|
|
case 'Infinity':
|
|
retArr.push('intBitsToFloat(2139095039)');
|
|
break;
|
|
default:
|
|
const userArgumentName = this.getUserArgumentName(idtNode.name);
|
|
if (userArgumentName) {
|
|
retArr.push(`user_${userArgumentName}`);
|
|
} else {
|
|
retArr.push(`user_${idtNode.name}`);
|
|
}
|
|
}
|
|
|
|
return retArr;
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
WebGL2FunctionNode
|
|
};
|
|
},{"../web-gl/function-node":14}],20:[function(require,module,exports){
|
|
const {
|
|
WebGLKernel
|
|
} = require('../web-gl/kernel');
|
|
const {
|
|
WebGL2FunctionNode
|
|
} = require('./function-node');
|
|
const {
|
|
FunctionBuilder
|
|
} = require('../function-builder');
|
|
const {
|
|
utils
|
|
} = require('../../utils');
|
|
const {
|
|
Texture
|
|
} = require('../../texture');
|
|
const {
|
|
fragmentShader
|
|
} = require('./fragment-shader');
|
|
const {
|
|
vertexShader
|
|
} = require('./vertex-shader');
|
|
|
|
let isSupported = null;
|
|
let testCanvas = null;
|
|
let testContext = null;
|
|
let testExtensions = null;
|
|
let features = null;
|
|
|
|
class WebGL2Kernel extends WebGLKernel {
|
|
static get isSupported() {
|
|
if (isSupported !== null) {
|
|
return isSupported;
|
|
}
|
|
this.setupFeatureChecks();
|
|
isSupported = this.isContextMatch(testContext);
|
|
return isSupported;
|
|
}
|
|
|
|
static setupFeatureChecks() {
|
|
if (typeof document !== 'undefined') {
|
|
testCanvas = document.createElement('canvas');
|
|
} else if (typeof OffscreenCanvas !== 'undefined') {
|
|
testCanvas = new OffscreenCanvas(0, 0);
|
|
}
|
|
|
|
if (testCanvas) {
|
|
testContext = testCanvas.getContext('webgl2');
|
|
if (!testContext) return;
|
|
testExtensions = {
|
|
EXT_color_buffer_float: testContext.getExtension('EXT_color_buffer_float'),
|
|
OES_texture_float_linear: testContext.getExtension('OES_texture_float_linear'),
|
|
};
|
|
features = this.getFeatures();
|
|
}
|
|
}
|
|
|
|
static isContextMatch(context) {
|
|
if (typeof WebGL2RenderingContext !== 'undefined') {
|
|
return context instanceof WebGL2RenderingContext;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static getFeatures() {
|
|
return Object.freeze({
|
|
isFloatRead: this.getIsFloatRead(),
|
|
isIntegerDivisionAccurate: this.getIsIntegerDivisionAccurate(),
|
|
kernelMap: true
|
|
});
|
|
}
|
|
|
|
static getIsIntegerDivisionAccurate() {
|
|
return super.getIsIntegerDivisionAccurate();
|
|
}
|
|
|
|
static get testCanvas() {
|
|
return testCanvas;
|
|
}
|
|
|
|
static get testContext() {
|
|
return testContext;
|
|
}
|
|
|
|
static get features() {
|
|
return features;
|
|
}
|
|
|
|
static get fragmentShader() {
|
|
return fragmentShader;
|
|
}
|
|
static get vertexShader() {
|
|
return vertexShader;
|
|
}
|
|
|
|
initContext() {
|
|
const settings = {
|
|
alpha: false,
|
|
depth: false,
|
|
antialias: false
|
|
};
|
|
const context = this.canvas.getContext('webgl2', settings);
|
|
return context;
|
|
}
|
|
|
|
initExtensions() {
|
|
this.extensions = {
|
|
EXT_color_buffer_float: this.context.getExtension('EXT_color_buffer_float'),
|
|
OES_texture_float_linear: this.context.getExtension('OES_texture_float_linear'),
|
|
};
|
|
}
|
|
|
|
validateSettings() {
|
|
if (this.skipValidate) {
|
|
this.texSize = utils.dimToTexSize({
|
|
floatTextures: this.floatTextures,
|
|
floatOutput: this.floatOutput
|
|
}, this.output, true);
|
|
return;
|
|
}
|
|
|
|
const features = this.constructor.features;
|
|
if (this.floatOutput === true && this.floatOutputForce !== true && !features.isFloatRead) {
|
|
throw new Error('Float texture outputs are not supported');
|
|
} else if (this.floatTextures === undefined) {
|
|
this.floatTextures = true;
|
|
this.floatOutput = features.isFloatRead;
|
|
}
|
|
|
|
if (this.fixIntegerDivisionAccuracy === null) {
|
|
this.fixIntegerDivisionAccuracy = !features.isIntegerDivisionAccurate;
|
|
} else if (this.fixIntegerDivisionAccuracy && features.isIntegerDivisionAccurate) {
|
|
this.fixIntegerDivisionAccuracy = false;
|
|
}
|
|
|
|
this.checkOutput();
|
|
|
|
if (!this.output || this.output.length === 0) {
|
|
if (arguments.length !== 1) {
|
|
throw new Error('Auto output only supported for kernels with only one input');
|
|
}
|
|
|
|
const argType = utils.getVariableType(arguments[0]);
|
|
if (argType === 'Array') {
|
|
this.output = utils.getDimensions(argType);
|
|
} else if (argType === 'NumberTexture' || argType === 'ArrayTexture(4)') {
|
|
this.output = arguments[0].output;
|
|
} else {
|
|
throw new Error('Auto output not supported for input type: ' + argType);
|
|
}
|
|
}
|
|
|
|
this.texSize = utils.dimToTexSize({
|
|
floatTextures: this.floatTextures,
|
|
floatOutput: this.floatOutput
|
|
}, this.output, true);
|
|
|
|
if (this.graphical) {
|
|
if (this.output.length !== 2) {
|
|
throw new Error('Output must have 2 dimensions on graphical mode');
|
|
}
|
|
|
|
if (this.floatOutput) {
|
|
this.floatOutput = false;
|
|
console.warn('Cannot use graphical mode and float output at the same time');
|
|
}
|
|
|
|
this.texSize = utils.clone(this.output);
|
|
} else if (this.floatOutput === undefined) {
|
|
this.floatOutput = true;
|
|
}
|
|
|
|
if (this.floatOutput || this.floatOutputForce) {
|
|
this.context.getExtension('EXT_color_buffer_float');
|
|
}
|
|
}
|
|
|
|
run() {
|
|
if (this.program === null) {
|
|
this.build.apply(this, arguments);
|
|
}
|
|
const argumentNames = this.argumentNames;
|
|
const argumentTypes = this.argumentTypes;
|
|
const texSize = this.texSize;
|
|
const gl = this.context;
|
|
|
|
gl.useProgram(this.program);
|
|
gl.scissor(0, 0, texSize[0], texSize[1]);
|
|
|
|
if (!this.hardcodeConstants) {
|
|
this.setUniform3iv('uOutputDim', new Int32Array(this.threadDim));
|
|
this.setUniform2iv('uTexSize', texSize);
|
|
}
|
|
|
|
this.setUniform2f('ratio', texSize[0] / this.maxTexSize[0], texSize[1] / this.maxTexSize[1]);
|
|
|
|
this.argumentsLength = 0;
|
|
for (let texIndex = 0; texIndex < argumentNames.length; texIndex++) {
|
|
this._addArgument(arguments[texIndex], argumentTypes[texIndex], argumentNames[texIndex]);
|
|
}
|
|
|
|
if (this.plugins) {
|
|
for (let i = 0; i < this.plugins.length; i++) {
|
|
const plugin = this.plugins[i];
|
|
if (plugin.onBeforeRun) {
|
|
plugin.onBeforeRun(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.graphical) {
|
|
if (this.pipeline) {
|
|
gl.bindRenderbuffer(gl.RENDERBUFFER, null);
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
|
|
if (!this.outputTexture || this.immutable) {
|
|
this._setupOutputTexture();
|
|
}
|
|
gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
|
|
return new Texture(this.outputTexture, texSize, this.threadDim, this.output, this.context, 'ArrayTexture(4)');
|
|
}
|
|
gl.bindRenderbuffer(gl.RENDERBUFFER, null);
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
|
|
gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
|
|
return;
|
|
}
|
|
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
|
|
if (this.immutable) {
|
|
this._setupOutputTexture();
|
|
}
|
|
const outputTexture = this.outputTexture;
|
|
|
|
if (this.subKernels !== null) {
|
|
if (this.immutable) {
|
|
this.subKernelOutputTextures = [];
|
|
this._setupSubOutputTextures(this.subKernels.length);
|
|
}
|
|
gl.drawBuffers(this.drawBuffersMap);
|
|
}
|
|
|
|
gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
|
|
|
|
if (this.subKernelOutputTextures !== null) {
|
|
if (this.subKernels !== null) {
|
|
const output = {
|
|
result: this.renderOutput(outputTexture)
|
|
};
|
|
for (let i = 0; i < this.subKernels.length; i++) {
|
|
output[this.subKernels[i].property] = new Texture(this.subKernelOutputTextures[i], texSize, this.threadDim, this.output, this.context);
|
|
}
|
|
return output;
|
|
}
|
|
}
|
|
|
|
return this.renderOutput(outputTexture);
|
|
}
|
|
|
|
drawBuffers() {
|
|
this.context.drawBuffers(this.drawBuffersMap);
|
|
}
|
|
|
|
getOutputTexture() {
|
|
return this.outputTexture;
|
|
}
|
|
|
|
_setupOutputTexture() {
|
|
const gl = this.context;
|
|
const texSize = this.texSize;
|
|
const texture = this.outputTexture = this.context.createTexture();
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentNames.length);
|
|
gl.bindTexture(gl.TEXTURE_2D, texture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
if (this.floatOutput) {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, texSize[0], texSize[1], 0, gl.RGBA, gl.FLOAT, null);
|
|
} else {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texSize[0], texSize[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
|
|
}
|
|
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
|
|
}
|
|
|
|
_setupSubOutputTextures(length) {
|
|
const gl = this.context;
|
|
const texSize = this.texSize;
|
|
const drawBuffersMap = this.drawBuffersMap = [gl.COLOR_ATTACHMENT0];
|
|
const textures = this.subKernelOutputTextures = [];
|
|
for (let i = 0; i < length; i++) {
|
|
const texture = this.context.createTexture();
|
|
textures.push(texture);
|
|
drawBuffersMap.push(gl.COLOR_ATTACHMENT0 + i + 1);
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentNames.length + i);
|
|
gl.bindTexture(gl.TEXTURE_2D, texture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
if (this.floatOutput) {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, texSize[0], texSize[1], 0, gl.RGBA, gl.FLOAT, null);
|
|
} else {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texSize[0], texSize[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
|
|
}
|
|
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i + 1, gl.TEXTURE_2D, texture, 0);
|
|
}
|
|
}
|
|
|
|
|
|
_addArgument(value, type, name) {
|
|
const gl = this.context;
|
|
const argumentTexture = this.getArgumentTexture(name);
|
|
if (value instanceof Texture) {
|
|
type = value.type;
|
|
}
|
|
switch (type) {
|
|
case 'Array':
|
|
{
|
|
const dim = utils.getDimensions(value, true);
|
|
const size = utils.dimToTexSize({
|
|
floatTextures: this.floatTextures,
|
|
floatOutput: this.floatOutput
|
|
}, dim);
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
|
|
let length = size[0] * size[1];
|
|
|
|
const {
|
|
valuesFlat,
|
|
bitRatio
|
|
} = this._formatArrayTransfer(value, length);
|
|
|
|
let buffer;
|
|
if (this.floatTextures) {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, size[0], size[1], 0, gl.RGBA, gl.FLOAT, valuesFlat);
|
|
} else {
|
|
buffer = new Uint8Array(valuesFlat.buffer);
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
|
|
}
|
|
|
|
if (!this.hardcodeConstants) {
|
|
this.setUniform3iv(`user_${name}Dim`, dim);
|
|
this.setUniform2iv(`user_${name}Size`, size);
|
|
}
|
|
this.setUniform1i(`user_${name}BitRatio`, bitRatio);
|
|
this.setUniform1i(`user_${name}`, this.argumentsLength);
|
|
break;
|
|
}
|
|
case 'Integer':
|
|
case 'Float':
|
|
case 'Number':
|
|
{
|
|
this.setUniform1f(`user_${name}`, value);
|
|
break;
|
|
}
|
|
case 'Input':
|
|
{
|
|
const input = value;
|
|
const dim = input.size;
|
|
const size = utils.dimToTexSize({
|
|
floatTextures: this.floatTextures,
|
|
floatOutput: this.floatOutput
|
|
}, dim);
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
|
|
let length = size[0] * size[1];
|
|
const {
|
|
valuesFlat,
|
|
bitRatio
|
|
} = this._formatArrayTransfer(value.value, length);
|
|
|
|
if (this.floatTextures) {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, size[0], size[1], 0, gl.RGBA, gl.FLOAT, inputArray);
|
|
} else {
|
|
const buffer = new Uint8Array(valuesFlat.buffer);
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
|
|
}
|
|
|
|
if (!this.hardcodeConstants) {
|
|
this.setUniform3iv(`user_${name}Dim`, dim);
|
|
this.setUniform2iv(`user_${name}Size`, size);
|
|
}
|
|
this.setUniform1i(`user_${name}BitRatio`, bitRatio);
|
|
this.setUniform1i(`user_${name}`, this.argumentsLength);
|
|
break;
|
|
}
|
|
case 'HTMLImage':
|
|
{
|
|
const inputImage = value;
|
|
const dim = [inputImage.width, inputImage.height, 1];
|
|
const size = [inputImage.width, inputImage.height];
|
|
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
|
|
const mipLevel = 0;
|
|
const internalFormat = gl.RGBA;
|
|
const srcFormat = gl.RGBA;
|
|
const srcType = gl.UNSIGNED_BYTE;
|
|
gl.texImage2D(gl.TEXTURE_2D,
|
|
mipLevel,
|
|
internalFormat,
|
|
srcFormat,
|
|
srcType,
|
|
inputImage);
|
|
this.setUniform3iv(`user_${name}Dim`, dim);
|
|
this.setUniform2iv(`user_${name}Size`, size);
|
|
this.setUniform1i(`user_${name}`, this.argumentsLength);
|
|
break;
|
|
}
|
|
case 'HTMLImageArray':
|
|
{
|
|
const inputImages = value;
|
|
const dim = [inputImages[0].width, inputImages[0].height, inputImages.length];
|
|
const size = [inputImages[0].width, inputImages[0].height];
|
|
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D_ARRAY, argumentTexture);
|
|
gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
|
|
const mipLevel = 0;
|
|
const internalFormat = gl.RGBA;
|
|
const width = inputImages[0].width;
|
|
const height = inputImages[0].height;
|
|
const textureDepth = inputImages.length;
|
|
const border = 0;
|
|
const srcFormat = gl.RGBA;
|
|
const srcType = gl.UNSIGNED_BYTE;
|
|
gl.texImage3D(
|
|
gl.TEXTURE_2D_ARRAY,
|
|
mipLevel,
|
|
internalFormat,
|
|
width,
|
|
height,
|
|
textureDepth,
|
|
border,
|
|
srcFormat,
|
|
srcType,
|
|
null
|
|
);
|
|
for (let i = 0; i < inputImages.length; i++) {
|
|
const xOffset = 0;
|
|
const yOffset = 0;
|
|
const imageDepth = 1;
|
|
gl.texSubImage3D(
|
|
gl.TEXTURE_2D_ARRAY,
|
|
mipLevel,
|
|
xOffset,
|
|
yOffset,
|
|
i,
|
|
inputImages[i].width,
|
|
inputImages[i].height,
|
|
imageDepth,
|
|
srcFormat,
|
|
srcType,
|
|
inputImages[i]
|
|
);
|
|
}
|
|
this.setUniform3iv(`user_${name}Dim`, dim);
|
|
this.setUniform2iv(`user_${name}Size`, size);
|
|
this.setUniform1i(`user_${name}`, this.argumentsLength);
|
|
break;
|
|
}
|
|
case 'ArrayTexture(4)':
|
|
case 'NumberTexture':
|
|
{
|
|
const inputTexture = value;
|
|
if (inputTexture.context !== this.context) {
|
|
throw new Error(`argument ${ name} (${ type }) must be from same context`);
|
|
}
|
|
const dim = inputTexture.dimensions;
|
|
const size = inputTexture.size;
|
|
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength + this.argumentsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, inputTexture.texture);
|
|
|
|
this.setUniform3iv(`user_${name}Dim`, dim);
|
|
this.setUniform2iv(`user_${name}Size`, size);
|
|
this.setUniform1i(`user_${name}BitRatio`, 1);
|
|
this.setUniform1i(`user_${name}`, this.argumentsLength);
|
|
break;
|
|
}
|
|
default:
|
|
throw new Error('Input type not supported: ' + value);
|
|
}
|
|
this.argumentsLength++;
|
|
}
|
|
|
|
_getMainConstantsString() {
|
|
const result = [];
|
|
if (this.constants) {
|
|
for (let name in this.constants) {
|
|
if (!this.constants.hasOwnProperty(name)) continue;
|
|
let value = this.constants[name];
|
|
let type = utils.getVariableType(value);
|
|
switch (type) {
|
|
case 'Integer':
|
|
result.push('const int constants_' + name + ' = ' + parseInt(value));
|
|
break;
|
|
case 'Float':
|
|
result.push('const float constants_' + name + ' = ' + parseFloat(value));
|
|
break;
|
|
case 'Array':
|
|
case 'Input':
|
|
case 'HTMLImage':
|
|
case 'ArrayTexture(4)':
|
|
case 'NumberTexture':
|
|
result.push(
|
|
`uniform highp sampler2D constants_${ name }`,
|
|
`uniform highp ivec2 constants_${ name }Size`,
|
|
`uniform highp ivec3 constants_${ name }Dim`,
|
|
`uniform highp int constants_${ name }BitRatio`
|
|
);
|
|
break;
|
|
case 'HTMLImageArray':
|
|
result.push(
|
|
`uniform highp sampler2DArray constants_${ name }`,
|
|
`uniform highp ivec2 constants_${ name }Size`,
|
|
`uniform highp ivec3 constants_${ name }Dim`,
|
|
`uniform highp int constants_${ name }BitRatio`
|
|
);
|
|
break;
|
|
|
|
default:
|
|
throw new Error(`Unsupported constant ${ name } type ${ type }`);
|
|
}
|
|
}
|
|
}
|
|
return this._linesToString(result);
|
|
}
|
|
|
|
_addConstant(value, type, name) {
|
|
const gl = this.context;
|
|
const argumentTexture = this.getArgumentTexture(name);
|
|
if (value instanceof Texture) {
|
|
type = value.type;
|
|
}
|
|
switch (type) {
|
|
case 'Array':
|
|
{
|
|
const dim = utils.getDimensions(value, true);
|
|
const size = utils.dimToTexSize({
|
|
floatTextures: this.floatTextures,
|
|
floatOutput: this.floatOutput
|
|
}, dim);
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
|
|
let length = size[0] * size[1];
|
|
|
|
const {
|
|
valuesFlat,
|
|
bitRatio
|
|
} = this._formatArrayTransfer(value, length);
|
|
|
|
let buffer;
|
|
if (this.floatTextures) {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0], size[1], 0, gl.RGBA, gl.FLOAT, valuesFlat);
|
|
} else {
|
|
buffer = new Uint8Array(valuesFlat.buffer);
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
|
|
}
|
|
|
|
if (!this.hardcodeConstants) {
|
|
this.setUniform3iv(`constants_${name}Dim`, dim);
|
|
this.setUniform2iv(`constants_${name}Size`, size);
|
|
}
|
|
this.setUniform1i(`constants_${name}BitRatio`, bitRatio);
|
|
this.setUniform1i(`constants_${name}`, this.constantsLength);
|
|
break;
|
|
}
|
|
case 'Input':
|
|
{
|
|
const input = value;
|
|
const dim = input.size;
|
|
const size = utils.dimToTexSize({
|
|
floatTextures: this.floatTextures,
|
|
floatOutput: this.floatOutput
|
|
}, dim);
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
|
|
let length = size[0] * size[1];
|
|
const {
|
|
valuesFlat,
|
|
bitRatio
|
|
} = this._formatArrayTransfer(value.value, length);
|
|
|
|
if (this.floatTextures) {
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, size[0], size[1], 0, gl.RGBA, gl.FLOAT, inputArray);
|
|
} else {
|
|
const buffer = new Uint8Array(valuesFlat.buffer);
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size[0] / bitRatio, size[1], 0, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
|
|
}
|
|
|
|
if (!this.hardcodeConstants) {
|
|
this.setUniform3iv(`constants_${name}Dim`, dim);
|
|
this.setUniform2iv(`constants_${name}Size`, size);
|
|
}
|
|
this.setUniform1i(`constants_${name}BitRatio`, bitRatio);
|
|
this.setUniform1i(`constants_${name}`, this.constantsLength);
|
|
break;
|
|
}
|
|
case 'HTMLImage':
|
|
{
|
|
const inputImage = value;
|
|
const dim = [inputImage.width, inputImage.height, 1];
|
|
const size = [inputImage.width, inputImage.height];
|
|
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, argumentTexture);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
|
|
const mipLevel = 0;
|
|
const internalFormat = gl.RGBA;
|
|
const srcFormat = gl.RGBA;
|
|
const srcType = gl.UNSIGNED_BYTE;
|
|
gl.texImage2D(gl.TEXTURE_2D,
|
|
mipLevel,
|
|
internalFormat,
|
|
srcFormat,
|
|
srcType,
|
|
inputImage);
|
|
this.setUniform3iv(`constants_${name}Dim`, dim);
|
|
this.setUniform2iv(`constants_${name}Size`, size);
|
|
this.setUniform1i(`constants_${name}`, this.constantsLength);
|
|
break;
|
|
}
|
|
case 'HTMLImageArray':
|
|
{
|
|
const inputImages = value;
|
|
const dim = [inputImages[0].width, inputImages[0].height, inputImages.length];
|
|
const size = [inputImages[0].width, inputImages[0].height];
|
|
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D_ARRAY, argumentTexture);
|
|
gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
|
|
gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
|
|
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
|
|
const mipLevel = 0;
|
|
const internalFormat = gl.RGBA;
|
|
const width = inputImages[0].width;
|
|
const height = inputImages[0].height;
|
|
const textureDepth = inputImages.length;
|
|
const border = 0;
|
|
const srcFormat = gl.RGBA;
|
|
const srcType = gl.UNSIGNED_BYTE;
|
|
gl.texImage3D(
|
|
gl.TEXTURE_2D_ARRAY,
|
|
mipLevel,
|
|
internalFormat,
|
|
width,
|
|
height,
|
|
textureDepth,
|
|
border,
|
|
srcFormat,
|
|
srcType,
|
|
null
|
|
);
|
|
for (let i = 0; i < inputImages.length; i++) {
|
|
const xOffset = 0;
|
|
const yOffset = 0;
|
|
const imageDepth = 1;
|
|
gl.texSubImage3D(
|
|
gl.TEXTURE_2D_ARRAY,
|
|
mipLevel,
|
|
xOffset,
|
|
yOffset,
|
|
i,
|
|
inputImages[i].width,
|
|
inputImages[i].height,
|
|
imageDepth,
|
|
srcFormat,
|
|
srcType,
|
|
inputImages[i]
|
|
);
|
|
}
|
|
this.setUniform3iv(`constants_${name}Dim`, dim);
|
|
this.setUniform2iv(`constants_${name}Size`, size);
|
|
this.setUniform1i(`constants_${name}`, this.constantsLength);
|
|
break;
|
|
}
|
|
case 'ArrayTexture(4)':
|
|
case 'NumberTexture':
|
|
{
|
|
const inputTexture = value;
|
|
if (inputTexture.context !== this.context) {
|
|
throw new Error(`argument ${ name} (${ type }) must be from same context`);
|
|
}
|
|
const dim = inputTexture.dimensions;
|
|
const size = inputTexture.size;
|
|
|
|
gl.activeTexture(gl.TEXTURE0 + this.constantsLength);
|
|
gl.bindTexture(gl.TEXTURE_2D, inputTexture.texture);
|
|
|
|
this.setUniform3iv(`constants_${name}Dim`, dim);
|
|
this.setUniform2iv(`constants_${name}Size`, size);
|
|
this.setUniform1i(`constants_${name}BitRatio`, 1);
|
|
this.setUniform1i(`constants_${name}`, this.constantsLength);
|
|
break;
|
|
}
|
|
case 'Integer':
|
|
case 'Float':
|
|
default:
|
|
throw new Error('Input type not supported: ' + value);
|
|
}
|
|
this.constantsLength++;
|
|
}
|
|
_getGetResultString() {
|
|
if (!this.floatTextures) {
|
|
return ' return decode(texel, x, bitRatio);';
|
|
}
|
|
return ' return texel[channel];';
|
|
}
|
|
|
|
_getHeaderString() {
|
|
return '';
|
|
}
|
|
|
|
_getTextureCoordinate() {
|
|
const subKernels = this.subKernels;
|
|
if (subKernels === null || subKernels.length < 1) {
|
|
return 'in highp vec2 vTexCoord;\n';
|
|
} else {
|
|
return 'out highp vec2 vTexCoord;\n';
|
|
}
|
|
}
|
|
|
|
_getMainArgumentsString(args) {
|
|
const result = [];
|
|
const argumentTypes = this.argumentTypes;
|
|
const argumentNames = this.argumentNames;
|
|
for (let i = 0; i < argumentNames.length; i++) {
|
|
const value = args[i];
|
|
const name = argumentNames[i];
|
|
const type = argumentTypes[i];
|
|
if (this.hardcodeConstants) {
|
|
if (type === 'Array' || type === 'NumberTexture' || type === 'ArrayTexture(4)') {
|
|
const dim = utils.getDimensions(value, true);
|
|
const size = utils.dimToTexSize({
|
|
floatTextures: this.floatTextures,
|
|
floatOutput: this.floatOutput
|
|
}, dim);
|
|
|
|
result.push(
|
|
`uniform highp sampler2D user_${ name }`,
|
|
`highp ivec2 user_${ name }Size = ivec2(${ size[0] }, ${ size[1] })`,
|
|
`highp ivec3 user_${ name }Dim = ivec3(${ dim[0] }, ${ dim[1]}, ${ dim[2] })`,
|
|
`uniform highp int user_${ name }BitRatio`
|
|
);
|
|
} else if (type === 'Integer') {
|
|
result.push(`highp float user_${ name } = ${ value }.0`);
|
|
} else if (type === 'Float') {
|
|
result.push(`highp float user_${ name } = ${ value }`);
|
|
}
|
|
} else {
|
|
if (type === 'Array' || type === 'NumberTexture' || type === 'ArrayTexture(4)' || type === 'Input' || type === 'HTMLImage') {
|
|
result.push(
|
|
`uniform highp sampler2D user_${ name }`,
|
|
`uniform highp ivec2 user_${ name }Size`,
|
|
`uniform highp ivec3 user_${ name }Dim`
|
|
);
|
|
if (type !== 'HTMLImage') {
|
|
result.push(`uniform highp int user_${ name }BitRatio`)
|
|
}
|
|
} else if (type === 'HTMLImageArray') {
|
|
result.push(
|
|
`uniform highp sampler2DArray user_${ name }`,
|
|
`uniform highp ivec2 user_${ name }Size`,
|
|
`uniform highp ivec3 user_${ name }Dim`
|
|
);
|
|
} else if (type === 'Integer' || type === 'Float' || type === 'Number') {
|
|
result.push(`uniform float user_${ name }`);
|
|
} else {
|
|
throw new Error(`Param type ${type} not supported in WebGL2`);
|
|
}
|
|
}
|
|
}
|
|
return this._linesToString(result);
|
|
}
|
|
|
|
_getKernelString() {
|
|
const result = [];
|
|
const subKernels = this.subKernels;
|
|
if (subKernels !== null) {
|
|
result.push('float kernelResult = 0.0');
|
|
result.push('layout(location = 0) out vec4 data0');
|
|
for (let i = 0; i < subKernels.length; i++) {
|
|
result.push(
|
|
`float subKernelResult_${ subKernels[i].name } = 0.0`,
|
|
`layout(location = ${ i + 1 }) out vec4 data${ i + 1 }`
|
|
);
|
|
}
|
|
} else {
|
|
result.push('out vec4 data0');
|
|
result.push('float kernelResult = 0.0');
|
|
}
|
|
|
|
const functionBuilder = FunctionBuilder.fromKernel(this, WebGL2FunctionNode, {
|
|
fixIntegerDivisionAccuracy: this.fixIntegerDivisionAccuracy
|
|
});
|
|
|
|
return this._linesToString(result) + functionBuilder.getPrototypeString('kernel');
|
|
}
|
|
|
|
_getMainResultString() {
|
|
const subKernels = this.subKernels;
|
|
const result = [];
|
|
|
|
if (this.floatOutput) {
|
|
result.push(' index *= 4');
|
|
}
|
|
|
|
if (this.graphical) {
|
|
result.push(
|
|
' threadId = indexTo3D(index, uOutputDim)',
|
|
' kernel()',
|
|
' data0 = actualColor'
|
|
);
|
|
} else if (this.floatOutput) {
|
|
const channels = ['r', 'g', 'b', 'a'];
|
|
|
|
for (let i = 0; i < channels.length; ++i) {
|
|
result.push(' threadId = indexTo3D(index, uOutputDim)');
|
|
result.push(' kernel()');
|
|
|
|
if (subKernels) {
|
|
result.push(` data0.${channels[i]} = kernelResult`);
|
|
|
|
for (let j = 0; j < subKernels.length; ++j) {
|
|
result.push(` data${ j + 1 }.${channels[i]} = subKernelResult_${ subKernels[j].name }`);
|
|
}
|
|
} else {
|
|
result.push(` data0.${channels[i]} = kernelResult`);
|
|
}
|
|
|
|
if (i < channels.length - 1) {
|
|
result.push(' index += 1');
|
|
}
|
|
}
|
|
} else if (subKernels !== null) {
|
|
result.push(' threadId = indexTo3D(index, uOutputDim)');
|
|
result.push(' kernel()');
|
|
result.push(' data0 = encode32(kernelResult)');
|
|
for (let i = 0; i < subKernels.length; i++) {
|
|
result.push(` data${ i + 1 } = encode32(subKernelResult_${ subKernels[i].name })`);
|
|
}
|
|
} else {
|
|
result.push(
|
|
' threadId = indexTo3D(index, uOutputDim)',
|
|
' kernel()',
|
|
' data0 = encode32(kernelResult)'
|
|
);
|
|
}
|
|
|
|
return this._linesToString(result);
|
|
}
|
|
|
|
getFragmentShader(args) {
|
|
if (this.compiledFragmentShader !== null) {
|
|
return this.compiledFragmentShader;
|
|
}
|
|
return this.compiledFragmentShader = this.replaceArtifacts(this.constructor.fragmentShader, this._getFragShaderArtifactMap(args));
|
|
}
|
|
|
|
getVertexShader(args) {
|
|
if (this.compiledVertexShader !== null) {
|
|
return this.compiledVertexShader;
|
|
}
|
|
return this.compiledVertexShader = this.constructor.vertexShader;
|
|
}
|
|
|
|
destroyExtensions() {
|
|
this.extensions.EXT_color_buffer_float = null;
|
|
this.extensions.OES_texture_float_linear = null;
|
|
}
|
|
|
|
toJSON() {
|
|
const json = super.toJSON();
|
|
json.functionNodes = FunctionBuilder.fromKernel(this, WebGL2FunctionNode).toJSON();
|
|
return json;
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
WebGL2Kernel
|
|
};
|
|
},{"../../texture":28,"../../utils":29,"../function-builder":8,"../web-gl/kernel":16,"./fragment-shader":18,"./function-node":19,"./vertex-shader":21}],21:[function(require,module,exports){
|
|
const vertexShader = `#version 300 es
|
|
precision highp float;
|
|
precision highp int;
|
|
precision highp sampler2D;
|
|
|
|
in vec2 aPos;
|
|
in vec2 aTexCoord;
|
|
|
|
out vec2 vTexCoord;
|
|
uniform vec2 ratio;
|
|
|
|
void main(void) {
|
|
gl_Position = vec4((aPos + vec2(1)) * ratio + vec2(-1), 0, 1);
|
|
vTexCoord = aTexCoord;
|
|
}`;
|
|
|
|
module.exports = {
|
|
vertexShader
|
|
};
|
|
},{}],22:[function(require,module,exports){
|
|
const lib = require('./index');
|
|
const GPU = lib.GPU;
|
|
for (const p in lib) {
|
|
if (!lib.hasOwnProperty(p)) continue;
|
|
if (p === 'GPU') continue;
|
|
GPU[p] = lib[p];
|
|
}
|
|
if (typeof module !== 'undefined') {
|
|
module.exports = GPU;
|
|
}
|
|
if (typeof window !== 'undefined') {
|
|
window.GPU = GPU;
|
|
}
|
|
if (typeof self !== 'undefined') {
|
|
self.GPU = GPU;
|
|
}
|
|
},{"./index":24}],23:[function(require,module,exports){
|
|
const gpuMock = require('gpu-mock.js');
|
|
const {
|
|
utils
|
|
} = require('./utils');
|
|
const {
|
|
CPUKernel
|
|
} = require('./backend/cpu/kernel');
|
|
const {
|
|
HeadlessGLKernel
|
|
} = require('./backend/headless-gl/kernel');
|
|
const {
|
|
WebGL2Kernel
|
|
} = require('./backend/web-gl2/kernel');
|
|
const {
|
|
WebGLKernel
|
|
} = require('./backend/web-gl/kernel');
|
|
const {
|
|
kernelRunShortcut
|
|
} = require('./kernel-run-shortcut');
|
|
|
|
|
|
const kernelOrder = [HeadlessGLKernel, WebGL2Kernel, WebGLKernel];
|
|
|
|
const kernelTypes = ['gpu', 'cpu'];
|
|
|
|
const internalKernels = {
|
|
'headlessgl': HeadlessGLKernel,
|
|
'webgl2': WebGL2Kernel,
|
|
'webgl': WebGLKernel,
|
|
};
|
|
|
|
class GPU {
|
|
static get isGPUSupported() {
|
|
return kernelOrder.some(Kernel => Kernel.isSupported);
|
|
}
|
|
|
|
static get isKernelMapSupported() {
|
|
return kernelOrder.some(Kernel => Kernel.isSupported && Kernel.features.kernelMap);
|
|
}
|
|
|
|
static get isOffscreenCanvasSupported() {
|
|
return (typeof Worker !== 'undefined' && typeof OffscreenCanvas !== 'undefined') || typeof importScripts !== 'undefined';
|
|
}
|
|
|
|
static get isWebGLSupported() {
|
|
return WebGLKernel.isSupported;
|
|
}
|
|
|
|
static get isWebGL2Supported() {
|
|
return WebGL2Kernel.isSupported;
|
|
}
|
|
|
|
static get isHeadlessGLSupported() {
|
|
return HeadlessGLKernel.isSupported;
|
|
}
|
|
|
|
static get isCanvasSupported() {
|
|
return typeof HTMLCanvasElement !== 'undefined';
|
|
}
|
|
|
|
static get isGPUHTMLImageArraySupported() {
|
|
return WebGL2Kernel.isSupported;
|
|
}
|
|
|
|
static get isFloatOutputSupported() {
|
|
return kernelOrder.some(Kernel => Kernel.isSupported && Kernel.features.isFloatRead && Kernel.features.isTextureFloat);
|
|
}
|
|
|
|
constructor(settings) {
|
|
settings = settings || {};
|
|
this.canvas = settings.canvas || null;
|
|
this.context = settings.context || null;
|
|
this.mode = settings.mode;
|
|
if (this.mode === 'dev') return;
|
|
this.Kernel = null;
|
|
this.kernels = [];
|
|
this.functions = [];
|
|
this.nativeFunctions = [];
|
|
|
|
if (settings.functions) {
|
|
for (let i = 0; i < settings.functions.length; i++) {
|
|
this.addFunction(settings.functions[i]);
|
|
}
|
|
}
|
|
|
|
if (settings.nativeFunctions) {
|
|
for (const p in settings.nativeFunctions) {
|
|
this.addNativeFunction(p, settings.nativeFunctions[p]);
|
|
}
|
|
}
|
|
|
|
this.chooseKernel();
|
|
}
|
|
|
|
chooseKernel() {
|
|
if (this.Kernel) return;
|
|
|
|
let Kernel = null;
|
|
|
|
if (this.context) {
|
|
for (let i = 0; i < kernelOrder.length; i++) {
|
|
const ExternalKernel = kernelOrder[i];
|
|
if (ExternalKernel.isContextMatch(this.context)) {
|
|
Kernel = ExternalKernel;
|
|
break;
|
|
}
|
|
}
|
|
if (Kernel === null) {
|
|
throw new Error('unknown Context');
|
|
}
|
|
} else if (this.mode) {
|
|
if (this.mode in internalKernels) {
|
|
if (internalKernels[this.mode].isSupported) {
|
|
Kernel = internalKernels[this.mode];
|
|
}
|
|
} else if (this.mode === 'gpu') {
|
|
for (let i = 0; i < kernelOrder.length; i++) {
|
|
if (kernelOrder[i].isSupported) {
|
|
Kernel = kernelOrder[i];
|
|
break;
|
|
}
|
|
}
|
|
} else if (this.mode === 'cpu') {
|
|
Kernel = CPUKernel;
|
|
}
|
|
if (!Kernel) {
|
|
throw new Error(`A requested mode of "${this.mode}" and is not supported`);
|
|
}
|
|
} else {
|
|
for (let i = 0; i < kernelOrder.length; i++) {
|
|
if (kernelOrder[i].isSupported) {
|
|
Kernel = kernelOrder[i];
|
|
break;
|
|
}
|
|
}
|
|
if (!Kernel) {
|
|
Kernel = CPUKernel;
|
|
}
|
|
}
|
|
|
|
if (!this.mode) {
|
|
this.mode = Kernel.mode;
|
|
}
|
|
this.Kernel = Kernel;
|
|
}
|
|
|
|
createKernel(source, settings) {
|
|
if (typeof source === 'undefined') {
|
|
throw new Error('Missing source parameter');
|
|
}
|
|
if (typeof source !== 'object' && !utils.isFunction(source) && typeof source !== 'string') {
|
|
throw new Error('source parameter not a function');
|
|
}
|
|
|
|
if (this.mode === 'dev') {
|
|
return gpuMock(source, settings);
|
|
}
|
|
|
|
source = typeof source === 'function' ? source.toString() : source;
|
|
const mergedSettings = Object.assign({
|
|
context: this.context,
|
|
canvas: this.canvas,
|
|
functions: this.functions,
|
|
nativeFunctions: this.nativeFunctions
|
|
}, settings || {});
|
|
|
|
const kernel = kernelRunShortcut(new this.Kernel(source, mergedSettings));
|
|
|
|
if (!this.canvas) {
|
|
this.canvas = kernel.canvas;
|
|
}
|
|
|
|
if (!this.context) {
|
|
this.context = kernel.context;
|
|
}
|
|
|
|
this.kernels.push(kernel);
|
|
|
|
return kernel;
|
|
}
|
|
|
|
createKernelMap() {
|
|
let fn;
|
|
let settings;
|
|
if (typeof arguments[arguments.length - 2] === 'function') {
|
|
fn = arguments[arguments.length - 2];
|
|
settings = arguments[arguments.length - 1];
|
|
} else {
|
|
fn = arguments[arguments.length - 1];
|
|
}
|
|
|
|
if (!this.Kernel.isSupported || !this.Kernel.features.kernelMap) {
|
|
if (this.mode && kernelTypes.indexOf(this.mode) < 0) {
|
|
throw new Error(`kernelMap not supported on ${this.Kernel.name}`);
|
|
}
|
|
}
|
|
|
|
const kernel = this.createKernel(fn, settings);
|
|
if (Array.isArray(arguments[0])) {
|
|
const functions = arguments[0];
|
|
for (let i = 0; i < functions.length; i++) {
|
|
const source = functions[i].toString();
|
|
const name = utils.getFunctionNameFromString(source);
|
|
kernel.addSubKernel({
|
|
name,
|
|
source,
|
|
property: i,
|
|
});
|
|
}
|
|
} else {
|
|
const functions = arguments[0];
|
|
for (let p in functions) {
|
|
if (!functions.hasOwnProperty(p)) continue;
|
|
const source = functions[p].toString();
|
|
const name = utils.getFunctionNameFromString(source);
|
|
kernel.addSubKernel({
|
|
name: name || p,
|
|
source,
|
|
property: p,
|
|
});
|
|
}
|
|
}
|
|
|
|
return kernel;
|
|
}
|
|
|
|
combineKernels() {
|
|
const lastKernel = arguments[arguments.length - 2];
|
|
const combinedKernel = arguments[arguments.length - 1];
|
|
if (this.mode === 'cpu') return combinedKernel;
|
|
|
|
const canvas = arguments[0].canvas;
|
|
let context = arguments[0].context;
|
|
|
|
for (let i = 0; i < arguments.length - 1; i++) {
|
|
arguments[i]
|
|
.setCanvas(canvas)
|
|
.setContext(context)
|
|
.setPipeline(true);
|
|
}
|
|
|
|
return function() {
|
|
combinedKernel.apply(null, arguments);
|
|
const texSize = lastKernel.texSize;
|
|
const gl = lastKernel.context;
|
|
const threadDim = lastKernel.threadDim;
|
|
let result;
|
|
if (lastKernel.floatOutput) {
|
|
const w = texSize[0];
|
|
const h = Math.ceil(texSize[1] / 4);
|
|
result = new Float32Array(w * h * 4);
|
|
gl.readPixels(0, 0, w, h, gl.RGBA, gl.FLOAT, result);
|
|
} else {
|
|
const bytes = new Uint8Array(texSize[0] * texSize[1] * 4);
|
|
gl.readPixels(0, 0, texSize[0], texSize[1], gl.RGBA, gl.UNSIGNED_BYTE, bytes);
|
|
result = new Float32Array(bytes.buffer);
|
|
}
|
|
|
|
result = result.subarray(0, threadDim[0] * threadDim[1] * threadDim[2]);
|
|
|
|
if (lastKernel.output.length === 1) {
|
|
return result;
|
|
} else if (lastKernel.output.length === 2) {
|
|
return utils.splitArray(result, lastKernel.output[0]);
|
|
} else if (lastKernel.output.length === 3) {
|
|
const cube = utils.splitArray(result, lastKernel.output[0] * lastKernel.output[1]);
|
|
return cube.map(function(x) {
|
|
return utils.splitArray(x, lastKernel.output[0]);
|
|
});
|
|
}
|
|
};
|
|
}
|
|
|
|
addFunction(source, settings) {
|
|
settings = settings || {};
|
|
if (typeof source !== 'string' && typeof source !== 'function') throw new Error('source not a string or function');
|
|
const sourceString = typeof source === 'string' ? source : source.toString();
|
|
|
|
let argumentTypes = [];
|
|
|
|
if (typeof settings.argumentTypes === 'object') {
|
|
argumentTypes = utils.getArgumentNamesFromString(sourceString)
|
|
.map(name => settings.argumentTypes[name]) || [];
|
|
} else {
|
|
argumentTypes = settings.argumentTypes || [];
|
|
}
|
|
|
|
this.functions.push({
|
|
source: sourceString,
|
|
argumentTypes,
|
|
returnType: settings.returnType
|
|
});
|
|
return this;
|
|
}
|
|
|
|
addNativeFunction(name, source, settings) {
|
|
if (this.kernels.length > 0) {
|
|
throw new Error('Cannot call "addNativeFunction" after "createKernels" has been called.');
|
|
}
|
|
this.nativeFunctions.push({
|
|
name,
|
|
source,
|
|
settings
|
|
});
|
|
return this;
|
|
}
|
|
|
|
destroy() {
|
|
setTimeout(() => {
|
|
for (let i = 0; i < this.kernels.length; i++) {
|
|
this.kernels[i].destroy(true);
|
|
}
|
|
this.kernels[0].kernel.constructor.destroyContext(this.context);
|
|
}, 0);
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
GPU,
|
|
kernelOrder,
|
|
kernelTypes
|
|
};
|
|
},{"./backend/cpu/kernel":7,"./backend/headless-gl/kernel":11,"./backend/web-gl/kernel":16,"./backend/web-gl2/kernel":20,"./kernel-run-shortcut":26,"./utils":29,"gpu-mock.js":3}],24:[function(require,module,exports){
|
|
const {
|
|
GPU
|
|
} = require('./gpu');
|
|
const {
|
|
alias
|
|
} = require('./alias');
|
|
const {
|
|
utils
|
|
} = require('./utils');
|
|
const {
|
|
Input,
|
|
input
|
|
} = require('./input');
|
|
const {
|
|
Texture
|
|
} = require('./texture');
|
|
const {
|
|
FunctionBuilder
|
|
} = require('./backend/function-builder');
|
|
const {
|
|
FunctionNode
|
|
} = require('./backend/function-node');
|
|
const {
|
|
CPUFunctionNode
|
|
} = require('./backend/cpu/function-node');
|
|
const {
|
|
CPUKernel
|
|
} = require('./backend/cpu/kernel');
|
|
|
|
const {
|
|
HeadlessGLKernel
|
|
} = require('./backend/headless-gl/kernel');
|
|
|
|
const {
|
|
WebGLFunctionNode
|
|
} = require('./backend/web-gl/function-node');
|
|
const {
|
|
WebGLKernel
|
|
} = require('./backend/web-gl/kernel');
|
|
|
|
const {
|
|
WebGL2FunctionNode
|
|
} = require('./backend/web-gl2/function-node');
|
|
const {
|
|
WebGL2Kernel
|
|
} = require('./backend/web-gl2/kernel');
|
|
|
|
module.exports = {
|
|
alias,
|
|
CPUFunctionNode,
|
|
CPUKernel,
|
|
GPU,
|
|
FunctionBuilder,
|
|
FunctionNode,
|
|
HeadlessGLKernel,
|
|
Input,
|
|
input,
|
|
Texture,
|
|
utils,
|
|
WebGL2FunctionNode,
|
|
WebGL2Kernel,
|
|
WebGLFunctionNode,
|
|
WebGLKernel,
|
|
};
|
|
},{"./alias":4,"./backend/cpu/function-node":5,"./backend/cpu/kernel":7,"./backend/function-builder":8,"./backend/function-node":9,"./backend/headless-gl/kernel":11,"./backend/web-gl/function-node":14,"./backend/web-gl/kernel":16,"./backend/web-gl2/function-node":19,"./backend/web-gl2/kernel":20,"./gpu":23,"./input":25,"./texture":28,"./utils":29}],25:[function(require,module,exports){
|
|
class Input {
|
|
constructor(value, size) {
|
|
this.value = value;
|
|
if (Array.isArray(size)) {
|
|
this.size = [];
|
|
for (let i = 0; i < size.length; i++) {
|
|
this.size[i] = size[i];
|
|
}
|
|
while (this.size.length < 3) {
|
|
this.size.push(1);
|
|
}
|
|
} else {
|
|
if (size.z) {
|
|
this.size = [size.x, size.y, size.z];
|
|
} else if (size.y) {
|
|
this.size = [size.x, size.y, 1];
|
|
} else {
|
|
this.size = [size.x, 1, 1];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function input(value, size) {
|
|
return new Input(value, size);
|
|
}
|
|
|
|
module.exports = {
|
|
Input,
|
|
input
|
|
};
|
|
},{}],26:[function(require,module,exports){
|
|
const {
|
|
utils
|
|
} = require('./utils');
|
|
|
|
function kernelRunShortcut(kernel) {
|
|
const shortcut = function() {
|
|
return kernel.run.apply(kernel, arguments);
|
|
};
|
|
|
|
utils
|
|
.allPropertiesOf(kernel)
|
|
.forEach((key) => {
|
|
if (key[0] === '_' && key[1] === '_') return;
|
|
if (typeof kernel[key] === 'function') {
|
|
if (key.substring(0, 3) === 'add' || key.substring(0, 3) === 'set') {
|
|
shortcut[key] = function() {
|
|
kernel[key].apply(kernel, arguments);
|
|
return shortcut;
|
|
};
|
|
} else {
|
|
shortcut[key] = kernel[key].bind(kernel);
|
|
}
|
|
} else {
|
|
shortcut.__defineGetter__(key, () => {
|
|
return kernel[key];
|
|
});
|
|
shortcut.__defineSetter__(key, (value) => {
|
|
kernel[key] = value;
|
|
});
|
|
}
|
|
});
|
|
|
|
shortcut.kernel = kernel;
|
|
|
|
return shortcut;
|
|
}
|
|
|
|
module.exports = {
|
|
kernelRunShortcut
|
|
};
|
|
},{"./utils":29}],27:[function(require,module,exports){
|
|
const source = `
|
|
|
|
uniform highp float triangle_noise_seed;
|
|
highp float triangle_noise_shift = 0.000001;
|
|
|
|
//https://www.shadertoy.com/view/4t2SDh
|
|
//note: uniformly distributed, normalized rand, [0;1[
|
|
float nrand( vec2 n )
|
|
{
|
|
return fract(sin(dot(n.xy, vec2(12.9898, 78.233)))* 43758.5453);
|
|
}
|
|
//note: remaps v to [0;1] in interval [a;b]
|
|
float remap( float a, float b, float v )
|
|
{
|
|
return clamp( (v-a) / (b-a), 0.0, 1.0 );
|
|
}
|
|
|
|
float n4rand( vec2 n )
|
|
{
|
|
float t = fract( triangle_noise_seed + triangle_noise_shift );
|
|
float nrnd0 = nrand( n + 0.07*t );
|
|
float nrnd1 = nrand( n + 0.11*t );
|
|
float nrnd2 = nrand( n + 0.13*t );
|
|
float nrnd3 = nrand( n + 0.17*t );
|
|
float result = (nrnd0+nrnd1+nrnd2+nrnd3) / 4.0;
|
|
triangle_noise_shift = result + 0.000001;
|
|
return result;
|
|
}`;
|
|
|
|
const name = 'triangle-noise-noise';
|
|
|
|
const functionMatch = 'Math.random()';
|
|
|
|
const functionReplace = 'n4rand(vTexCoord)';
|
|
|
|
const functionReturnType = 'Number';
|
|
|
|
const onBeforeRun = (kernel) => {
|
|
kernel.setUniform1f('triangle_noise_seed', Math.random());
|
|
};
|
|
|
|
module.exports = {
|
|
name,
|
|
onBeforeRun,
|
|
functionMatch,
|
|
functionReplace,
|
|
functionReturnType,
|
|
source
|
|
};
|
|
},{}],28:[function(require,module,exports){
|
|
class Texture {
|
|
constructor(texture, size, dimensions, output, context, type = 'NumberTexture') {
|
|
this.texture = texture;
|
|
this.size = size;
|
|
this.dimensions = dimensions;
|
|
this.output = output;
|
|
this.context = context;
|
|
this.kernel = null;
|
|
this.type = type;
|
|
}
|
|
|
|
toArray(gpu) {
|
|
if (!gpu) throw new Error('You need to pass the GPU object for toArray to work.');
|
|
if (this.kernel) return this.kernel(this);
|
|
|
|
this.kernel = gpu.createKernel(function(x) {
|
|
return x[this.thread.z][this.thread.y][this.thread.x];
|
|
}).setOutput(this.output);
|
|
|
|
return this.kernel(this);
|
|
}
|
|
|
|
delete() {
|
|
return this.context.deleteTexture(this.texture);
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
Texture
|
|
};
|
|
},{}],29:[function(require,module,exports){
|
|
const {
|
|
Input
|
|
} = require('./input');
|
|
const {
|
|
Texture
|
|
} = require('./texture');
|
|
|
|
const FUNCTION_NAME = /function ([^(]*)/;
|
|
const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
|
|
const ARGUMENT_NAMES = /([^\s,]+)/g;
|
|
|
|
const utils = {
|
|
systemEndianness() {
|
|
return _systemEndianness;
|
|
},
|
|
getSystemEndianness() {
|
|
const b = new ArrayBuffer(4);
|
|
const a = new Uint32Array(b);
|
|
const c = new Uint8Array(b);
|
|
a[0] = 0xdeadbeef;
|
|
if (c[0] === 0xef) return 'LE';
|
|
if (c[0] === 0xde) return 'BE';
|
|
throw new Error('unknown endianness');
|
|
},
|
|
|
|
isFunction(funcObj) {
|
|
return typeof(funcObj) === 'function';
|
|
},
|
|
|
|
isFunctionString(fn) {
|
|
if (typeof fn === 'string') {
|
|
return (fn
|
|
.slice(0, 'function'.length)
|
|
.toLowerCase() === 'function');
|
|
}
|
|
return false;
|
|
},
|
|
|
|
getFunctionNameFromString(funcStr) {
|
|
return FUNCTION_NAME.exec(funcStr)[1].trim();
|
|
},
|
|
|
|
getFunctionBodyFromString(funcStr) {
|
|
return funcStr.substring(funcStr.indexOf('{') + 1, funcStr.lastIndexOf('}'));
|
|
},
|
|
|
|
getArgumentNamesFromString(fn) {
|
|
const fnStr = fn.replace(STRIP_COMMENTS, '');
|
|
let result = fnStr.slice(fnStr.indexOf('(') + 1, fnStr.indexOf(')')).match(ARGUMENT_NAMES);
|
|
if (result === null) {
|
|
result = [];
|
|
}
|
|
return result;
|
|
},
|
|
|
|
clone(obj) {
|
|
if (obj === null || typeof obj !== 'object' || obj.hasOwnProperty('isActiveClone')) return obj;
|
|
|
|
const temp = obj.constructor();
|
|
|
|
for (let key in obj) {
|
|
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
|
obj.isActiveClone = null;
|
|
temp[key] = utils.clone(obj[key]);
|
|
delete obj.isActiveClone;
|
|
}
|
|
}
|
|
|
|
return temp;
|
|
},
|
|
|
|
isArray(array) {
|
|
return !isNaN(array.length);
|
|
},
|
|
|
|
getVariableType(value) {
|
|
if (utils.isArray(value)) {
|
|
if (value[0].nodeName === 'IMG') {
|
|
return 'HTMLImageArray';
|
|
}
|
|
return 'Array';
|
|
} else if (typeof value === 'number') {
|
|
if (Number.isInteger(value)) {
|
|
return 'Integer';
|
|
}
|
|
return 'Float';
|
|
} else if (value instanceof Texture) {
|
|
return value.type;
|
|
} else if (value instanceof Input) {
|
|
return 'Input';
|
|
} else if (value.nodeName === 'IMG') {
|
|
return 'HTMLImage';
|
|
} else {
|
|
return 'Unknown';
|
|
}
|
|
},
|
|
|
|
|
|
dimToTexSize(opt, dimensions, output) {
|
|
let numTexels = dimensions[0];
|
|
let w = dimensions[0];
|
|
let h = dimensions[1];
|
|
for (let i = 1; i < dimensions.length; i++) {
|
|
numTexels *= dimensions[i];
|
|
}
|
|
|
|
if (opt.floatTextures && (!output || opt.floatOutput)) {
|
|
w = numTexels = Math.ceil(numTexels / 4);
|
|
}
|
|
if (h > 1 && w * h === numTexels) {
|
|
return [w, h];
|
|
}
|
|
const sqrt = Math.sqrt(numTexels);
|
|
let high = Math.ceil(sqrt);
|
|
let low = Math.floor(sqrt);
|
|
while (high * low > numTexels) {
|
|
high--;
|
|
low = Math.ceil(numTexels / high);
|
|
}
|
|
w = low;
|
|
h = Math.ceil(numTexels / w);
|
|
return [w, h];
|
|
},
|
|
|
|
getDimensions(x, pad) {
|
|
let ret;
|
|
if (utils.isArray(x)) {
|
|
const dim = [];
|
|
let temp = x;
|
|
while (utils.isArray(temp)) {
|
|
dim.push(temp.length);
|
|
temp = temp[0];
|
|
}
|
|
ret = dim.reverse();
|
|
} else if (x instanceof Texture) {
|
|
ret = x.output;
|
|
} else if (x instanceof Input) {
|
|
ret = x.size;
|
|
} else {
|
|
throw new Error('Unknown dimensions of ' + x);
|
|
}
|
|
|
|
if (pad) {
|
|
ret = utils.clone(ret);
|
|
while (ret.length < 3) {
|
|
ret.push(1);
|
|
}
|
|
}
|
|
|
|
return new Int32Array(ret);
|
|
},
|
|
|
|
flatten2dArrayTo(array, target) {
|
|
let offset = 0;
|
|
for (let y = 0; y < array.length; y++) {
|
|
target.set(array[y], offset);
|
|
offset += array[y].length;
|
|
}
|
|
},
|
|
|
|
flatten3dArrayTo(array, target) {
|
|
let offset = 0;
|
|
for (let z = 0; z < array.length; z++) {
|
|
for (let y = 0; y < array[z].length; y++) {
|
|
target.set(array[z][y], offset);
|
|
offset += array[z][y].length;
|
|
}
|
|
}
|
|
},
|
|
|
|
flattenTo(array, target) {
|
|
if (utils.isArray(array[0])) {
|
|
if (utils.isArray(array[0][0])) {
|
|
utils.flatten3dArrayTo(array, target);
|
|
} else {
|
|
utils.flatten2dArrayTo(array, target);
|
|
}
|
|
} else {
|
|
target.set(array);
|
|
}
|
|
},
|
|
|
|
splitArray(array, part) {
|
|
const result = [];
|
|
for (let i = 0; i < array.length; i += part) {
|
|
result.push(new array.constructor(array.buffer, i * 4 + array.byteOffset, part));
|
|
}
|
|
return result;
|
|
},
|
|
|
|
getAstString(source, ast) {
|
|
const lines = Array.isArray(source) ? source : source.split(/\r?\n/g);
|
|
const start = ast.loc.start;
|
|
const end = ast.loc.end;
|
|
const result = [];
|
|
result.push(lines[start.line - 1].slice(start.column));
|
|
for (let i = start.line; i < end.line - 1; i++) {
|
|
result.push(lines[i]);
|
|
}
|
|
result.push(lines[end.line - 1].slice(0, end.column));
|
|
return result.join('\n');
|
|
},
|
|
|
|
allPropertiesOf(obj) {
|
|
const props = [];
|
|
|
|
do {
|
|
props.push.apply(props, Object.getOwnPropertyNames(obj));
|
|
} while (obj = Object.getPrototypeOf(obj));
|
|
|
|
return props;
|
|
}
|
|
};
|
|
|
|
const _systemEndianness = utils.getSystemEndianness();
|
|
|
|
module.exports = {
|
|
utils
|
|
};
|
|
},{"./input":25,"./texture":28}]},{},[22]);
|