@scriptc/compiler 0.2.0 → 0.2.1

package/dist/ir/validate.js

@@ -40,6 +40,8 @@ export const REGEX_INTRINSIC_SIGS = {
     // VOID here is the process.envGet sentinel; the regexIntrinsic case
     // checks the union's arms.
     match: { receiver: STRING, argTypes: [REGEX], result: VOID },
+    exec: { receiver: STRING, argTypes: [REGEX], result: VOID },
+    lastIndex: { receiver: REGEX, argTypes: [], result: F64 },
     matchAll: { receiver: STRING, argTypes: [REGEX], result: arrayOf(arrayOf(STRING)) },
     matchAllInto: { receiver: STRING, argTypes: [REGEX, arrayOf(F64)], result: arrayOf(arrayOf(STRING)) },
     search: { receiver: STRING, argTypes: [REGEX], result: F64 },
@@ -60,6 +62,10 @@ export const REGEX_INTRINSIC_SIGS = {
 export const LIB_FN_SIGS = {
     "fetch.start": { argTypes: [STRING, DYN], result: { kind: "promise", inner: DYN } },
     "fetch.responseNew": { argTypes: [DYN, DYN], result: DYN },
+    "fetch.input": { argTypes: [DYN, DYN], result: { kind: "promise", inner: DYN } },
+    "fetch.function": { argTypes: [], result: DYN },
+    "fetch.requestNew": { argTypes: [DYN, DYN], result: DYN },
+    "fetch.headersNew": { argTypes: [DYN], result: DYN },
     "fetch.responseArrayBuffer": { argTypes: [DYN], result: { kind: "promise", inner: DYN } },
     "fetch.responseJson": { argTypes: [DYN], result: { kind: "promise", inner: DYN } },
     "fetch.responseText": { argTypes: [DYN], result: { kind: "promise", inner: STRING } },
@@ -72,6 +78,8 @@ export const LIB_FN_SIGS = {
     // Program-dependent iterable: typed arrays/bytes/string stay intact so
     // the native stream can pull lazily; checked-dynamic values are the
     // fallback. The libCall validator below checks the closed set.
+    "fetch.webIs": { argTypes: [DYN, STRING], result: BOOL },
+    "fetch.streamIs": { argTypes: [DYN], result: BOOL },
     "fetch.streamFrom": { argTypes: [null], result: DYN },
     // The chunk/result record depends on ReadableStream<T>; validated below.
     "fetch.readerRead": { argTypes: [DYN], result: VOID },
@@ -97,6 +105,7 @@ export const LIB_FN_SIGS = {
     "dyn.globalSymbolHas": { argTypes: [SYMBOL_T], result: BOOL },
     "dyn.globalSymbolDelete": { argTypes: [SYMBOL_T], result: VOID },
     "dyn.typedRefIs": { argTypes: [DYN, STRING], result: BOOL },
+    "dyn.classIs": { argTypes: [DYN, STRING], result: BOOL },
     "dyn.iterPack": { argTypes: [DYN, STRING], result: DYN },
     "dyn.arrayFromIterator": { argTypes: [DYN], result: DYN },
     "dyn.iterator": { argTypes: [DYN, STRING], result: DYN },
@@ -280,11 +289,13 @@ export const LIB_FN_SIGS = {
     "str.btoa": { argTypes: [DYN], result: STRING },
     "str.b64Missing": { argTypes: [], result: STRING },
     "str.decodeUriComponent": { argTypes: [STRING], result: STRING },
+    "str.decodeUri": { argTypes: [STRING], result: STRING },
     "str.encodeUri": { argTypes: [STRING], result: STRING },
     "regexp.escape": { argTypes: [STRING], result: STRING },
     "num.toExponential": { argTypes: [F64], result: STRING },
     "num.toFixed0": { argTypes: [F64], result: STRING },
     "num.toFixed": { argTypes: [F64, F64], result: STRING },
+    "num.toStringRadix": { argTypes: [F64, DYN], result: STRING },
     "num.sameValue": { argTypes: [F64, F64], result: BOOL },
     "intl.numFormatEnUs": { argTypes: [F64], result: STRING },
     "sym.new": { argTypes: [STRING], result: SYMBOL_T },
@@ -343,6 +354,7 @@ export const LIB_FN_SIGS = {
     "url.pathToFileURLPlatform": { argTypes: [STRING, BOOL], result: URL_T },
     "url.pathToFileURLWin32": { argTypes: [STRING], result: URL_T },
     "sp.new": { argTypes: [], result: SEARCH_PARAMS_T },
+    "sp.newChecked": { argTypes: [DYN], result: SEARCH_PARAMS_T },
     "sp.parse": { argTypes: [STRING], result: SEARCH_PARAMS_T },
     "sp.copy": { argTypes: [SEARCH_PARAMS_T], result: SEARCH_PARAMS_T },
     // The pairs argument is string[][] — checked structurally below (the
@@ -856,6 +868,8 @@ export const LIB_FN_SIGS = {
     "child.disconnect": { argTypes: [CHILD_T], result: VOID },
     "child.onMessage": { argTypes: [CHILD_T, null, BOOL], result: VOID },
     "child.onDisconnect": { argTypes: [CHILD_T, null, BOOL], result: VOID },
+    "child.onSpawn": { argTypes: [CHILD_T, null], result: VOID },
+    "child.onDyn": { argTypes: [CHILD_T, STRING, DYN], result: VOID },
     "process.connected": { argTypes: [], result: BOOL },
     "process.send": { argTypes: [STRING], result: BOOL },
     "process.sendCb": { argTypes: [STRING, null], result: BOOL },
@@ -870,6 +884,7 @@ export const LIB_FN_SIGS = {
         argTypes: [STRING, arrayOf(STRING), F64, F64, F64, F64, F64, BOOL, BOOL, BOOL, arrayOf(STRING), STRING],
         result: CHILD_T,
     },
+    "cp.spawnDynamic": { argTypes: [STRING, arrayOf(STRING), DYN], result: CHILD_T },
     // The callback's func type is program-dependent (zero params, or the
     // `number | null` union / the %Error class) — the libCall case checks
     // the shape; the slot here only pins arity and the child receiver.
@@ -921,6 +936,7 @@ export const LIB_FN_SIGS = {
     "child.kill": { argTypes: [CHILD_T, STRING], result: BOOL },
     "child.killNum": { argTypes: [CHILD_T, F64], result: BOOL },
     "child.unref": { argTypes: [CHILD_T], result: VOID },
+    "child.ref": { argTypes: [CHILD_T], result: VOID },
     "spawnRes.stdout": { argTypes: [SPAWNRES_T], result: STRING },
     "spawnRes.stderr": { argTypes: [SPAWNRES_T], result: STRING },
     "crypto.randomUUID": { argTypes: [], result: STRING },
@@ -928,6 +944,7 @@ export const LIB_FN_SIGS = {
     "crypto.randomBytes": { argTypes: [F64], result: BYTES_U8 },
     "crypto.hashDigestStr": { argTypes: [STRING, STRING, STRING], result: STRING },
     "crypto.hashDigestBytes": { argTypes: [STRING, BYTES_U8, STRING], result: STRING },
+    "crypto.native": { argTypes: [], result: DYN },
     "crypto.hashNew": { argTypes: [STRING], result: CRYPTOHASH_T },
     "crypto.hmacNewStr": { argTypes: [STRING, STRING], result: CRYPTOHMAC_T },
     "crypto.hmacNewBytes": { argTypes: [STRING, BYTES_U8], result: CRYPTOHMAC_T },
@@ -953,6 +970,7 @@ export const LIB_FN_SIGS = {
     "buffer.brand": { argTypes: [BYTES_U8], result: BYTES_U8 },
     "buffer.fromDyn": { argTypes: [DYN, STRING], result: BYTES_U8 },
     "buffer.concat": { argTypes: [arrayOf(BYTES_U8)], result: BYTES_U8 },
+    "buffer.byteLenDyn": { argTypes: [DYN, STRING], result: F64 },
     "buffer.byteLenStr": { argTypes: [STRING, STRING], result: F64 },
     "buffer.isEncoding": { argTypes: [STRING], result: BOOL },
     "buffer.concatLen": { argTypes: [arrayOf(BYTES_U8), F64], result: BYTES_U8 },
@@ -1051,6 +1069,7 @@ export const LIB_FN_SIGS = {
     "process.cwd": { argTypes: [], result: STRING },
     "process.pid": { argTypes: [], result: F64 },
     "dyn.this": { argTypes: [], result: DYN },
+    "dyn.generatorThis": { argTypes: [], result: DYN },
     "process.getuid": { argTypes: [], result: F64 },
     "process.getgid": { argTypes: [], result: F64 },
     "process.execPath": { argTypes: [], result: STRING },
@@ -1059,6 +1078,8 @@ export const LIB_FN_SIGS = {
     "process.builtinId": { argTypes: [DYN, arrayOf(STRING)], result: STRING },
     "process.builtinModule": { argTypes: [STRING, DYN], result: DYN },
     "process.builtinUnsupported": { argTypes: [STRING, STRING], result: DYN },
+    "fs.callbackValue": { argTypes: [STRING], result: DYN },
+    "fs.callbackCall": { argTypes: [STRING, DYN], result: DYN },
     "process.hrtimeValue": { argTypes: [], result: DYN },
     "process.versionsNode": { argTypes: [], result: STRING },
     "process.versionsOpenssl": { argTypes: [], result: STRING },
@@ -1075,6 +1096,7 @@ export const LIB_FN_SIGS = {
     "error.cause": { argTypes: [null], result: DYN },
     "error.hasCause": { argTypes: [null], result: BOOL },
     "error.setCause": { argTypes: [null, DYN], result: VOID },
+    "error.defineCause": { argTypes: [null, DYN], result: VOID },
     "error.deleteCause": { argTypes: [null], result: VOID },
     "error.nodeThrow": { argTypes: [F64, STRING, STRING], result: VOID },
     "dyn.toStringCoerce": { argTypes: [DYN], result: STRING },
@@ -1083,9 +1105,11 @@ export const LIB_FN_SIGS = {
     "dyn.toNumeric": { argTypes: [DYN], result: DYN },
     "dyn.increment": { argTypes: [DYN, BOOL], result: DYN },
     "dyn.numberConstructor": { argTypes: [DYN], result: F64 },
+    "dyn.bigintConstructor": { argTypes: [DYN], result: BIGINT_T },
     "dyn.toNumberCoerce": { argTypes: [DYN], result: F64 },
     "dyn.add": { argTypes: [DYN, DYN], result: DYN },
     "dyn.arithmetic": { argTypes: [DYN, DYN, STRING], result: DYN },
+    "dyn.compare": { argTypes: [DYN, DYN, STRING], result: BOOL },
     "dyn.bitwise": { argTypes: [DYN, DYN, STRING], result: DYN },
     "dyn.proxyNew": { argTypes: [DYN, DYN], result: DYN },
     // Always throws; the result is the READ's declared type (a typed dummy
@@ -1098,6 +1122,7 @@ export const LIB_FN_SIGS = {
     "class.name": { argTypes: [null], result: STRING },
     "error.ctor": { argTypes: [null, STRING], result: VOID },
     "error.toString": { argTypes: [null], result: STRING },
+    "dyn.sameValue": { argTypes: [DYN, DYN], result: BOOL },
     "error.stack": { argTypes: [null], result: STRING },
     "error.stackLimitGet": { argTypes: [], result: F64 },
     "error.stackLimitSet": { argTypes: [F64], result: VOID },
@@ -1120,6 +1145,12 @@ export const LIB_FN_SIGS = {
     "weakMap.new": { argTypes: [DYN], result: DYN },
     "weakSet.new": { argTypes: [DYN], result: DYN },
     "dyn.fromEntries": { argTypes: [DYN], result: DYN },
+    "bytes.constructor": { argTypes: [STRING], result: DYN },
+    "bytes.instanceOf": { argTypes: [DYN, DYN], result: BOOL },
+    "bytes.construct": { argTypes: [DYN, DYN, STRING], result: DYN },
+    "dyn.dataViewIs": { argTypes: [DYN], result: BOOL },
+    "dyn.construct": { argTypes: [DYN, DYN, STRING], result: DYN },
+    "arrayBuffer.constructor": { argTypes: [], result: DYN },
     "arrayBuffer.new": { argTypes: [DYN], result: DYN },
     "ffi.argument": { argTypes: [DYN, STRING], result: DYN },
     "ffi.memoryModule": { argTypes: [DYN], result: DYN },
@@ -1144,14 +1175,20 @@ export const LIB_FN_SIGS = {
     "dyn.propertyIsEnumerable": { argTypes: [DYN, STRING], result: BOOL },
     "dyn.assign": { argTypes: [DYN, DYN], result: DYN },
     "dyn.copyDataProperties": { argTypes: [DYN, DYN], result: DYN },
+    "dyn.objectRest": { argTypes: [DYN, DYN], result: DYN },
     "dyn.packPush": { argTypes: [DYN, DYN], result: VOID },
     "dyn.packPushSpread": { argTypes: [DYN, DYN, STRING], result: VOID },
     "dyn.packPushSpreadIter": { argTypes: [DYN, DYN], result: VOID },
+    "dyn.reflectApply": { argTypes: [DYN, DYN, DYN], result: DYN },
     "dyn.assignAll": { argTypes: [DYN, DYN], result: DYN },
     "dyn.objCreateNullProto": { argTypes: [], result: DYN },
     "dyn.arrayPrototype": { argTypes: [], result: DYN },
+    "dyn.objectPrototype": { argTypes: [], result: DYN },
+    "dyn.functionApply": { argTypes: [], result: DYN },
+    "dyn.builtinMethod": { argTypes: [STRING, STRING], result: DYN },
     "dyn.classPrototype": { argTypes: [DYN, DYN], result: DYN },
     "dyn.classBasePrototype": { argTypes: [DYN], result: DYN },
+    "dyn.classInherit": { argTypes: [DYN, DYN], result: DYN },
     "dyn.classSuper": { argTypes: [DYN, DYN, DYN], result: VOID },
     "dyn.assignPrototype": { argTypes: [DYN, DYN, DYN], result: DYN },
     "dyn.objCreate": { argTypes: [DYN], result: DYN },
@@ -1159,6 +1196,7 @@ export const LIB_FN_SIGS = {
     "dyn.getPrototype": { argTypes: [DYN], result: DYN },
     "dyn.setPrototype": { argTypes: [DYN, DYN], result: DYN },
     "dyn.getOwnPropertyNames": { argTypes: [DYN], result: DYN },
+    "dyn.ownKeys": { argTypes: [DYN], result: DYN },
     "dyn.getOwnPropertySymbols": { argTypes: [DYN], result: DYN },
     "dyn.getOwnPropertyDescriptors": { argTypes: [DYN], result: DYN },
     "dyn.preventExtensions": { argTypes: [DYN], result: DYN },
@@ -1171,6 +1209,7 @@ export const LIB_FN_SIGS = {
     "dyn.cloneMissing": { argTypes: [], result: DYN },
     "dyn.cloneTransferFail": { argTypes: [], result: DYN },
     "regex.new": { argTypes: [STRING, STRING], result: REGEX },
+    "regex.resetLastIndex": { argTypes: [REGEX, F64], result: VOID },
     "regex.newChecked": { argTypes: [DYN, DYN], result: REGEX },
     // node:events EventEmitter: receivers are emitter-hierarchy objects and
     // the chaining forms (on/off/removeAll/setMax) return the receiver's
@@ -1258,6 +1297,8 @@ export const LIB_FN_SIGS = {
     "readable.pushDyn": { argTypes: [null, DYN], result: BOOL },
     "readable.unshift": { argTypes: [null, BYTES_U8], result: VOID },
     "readable.unshiftStr": { argTypes: [null, STRING], result: VOID },
+    "stream.onDyn": { argTypes: [null, STRING, DYN, BOOL, BOOL], result: VOID },
+    "readable.readDyn": { argTypes: [null, DYN], result: DYN },
     "readable.read": { argTypes: [null, F64], result: VOID },
     "readable.pause": { argTypes: [null], result: VOID },
     "readable.setEncoding": { argTypes: [null, STRING], result: VOID },
@@ -1437,7 +1478,13 @@ export const LIB_FN_SIGS = {
     "date.parseGetTime": { argTypes: [STRING], result: F64 },
     "date.utc": { argTypes: [F64, F64, F64, F64, F64, F64, F64], result: F64 },
     "text.decode": { argTypes: [BYTES_U8], result: STRING },
+    "bytes.bufferSource": { argTypes: [DYN], result: BYTES_U8 },
+    "text.decodeBufferSource": { argTypes: [DYN], result: STRING },
+    "text.decodeOptions": { argTypes: [BYTES_U8, BOOL, BOOL], result: STRING },
+    "text.decodeStream": { argTypes: [DYN, BYTES_U8, F64, BOOL, BOOL, BOOL], result: STRING },
+    "text.decodeLegacyOptions": { argTypes: [BYTES_U8, F64, BOOL, BOOL], result: STRING },
     "text.decodeLegacy": { argTypes: [BYTES_U8, F64], result: STRING },
+    "text.decoderEncoding": { argTypes: [DYN], result: F64 },
     "fs.mkdirRecursiveSync": { argTypes: [STRING], result: VOID },
     "fs.rmOptsSync": { argTypes: [STRING, BOOL, BOOL], result: VOID },
     "fs.rmRetrySync": { argTypes: [STRING, BOOL, BOOL, F64, F64], result: VOID },
@@ -1695,6 +1742,12 @@ export function validateModule(mod) {
                 errors.push({ message: `class ${cls.name}: invalid local base capture`, loc: cls.loc });
             }
         }
+        if (cls.baseValueGlobal !== undefined) {
+            const global = mod.globals?.find((global) => global.id === cls.baseValueGlobal);
+            if (cls.localBaseCapture !== undefined || !cls.base || global?.type.kind !== "classval" || global.type.className !== cls.base) {
+                errors.push({ message: `class ${cls.name}: invalid computed base global`, loc: cls.loc });
+            }
+        }
         if (cls.jsLength !== undefined && (!Number.isSafeInteger(cls.jsLength) || cls.jsLength < 0)) {
             errors.push({ message: `class ${cls.name}: invalid constructor length`, loc: cls.loc });
         }
@@ -1704,6 +1757,20 @@ export function validateModule(mod) {
                 errors.push({ message: `class ${cls.name}: prototype data helper must be a noncapturing () => dyn function`, loc: cls.loc });
             }
         }
+        if (cls.instancePrototypeHelper !== undefined) {
+            const helper = functionsByName.get(cls.instancePrototypeHelper);
+            const receiver = helper?.params[0]?.type;
+            if (!helper || helper.params.length !== 1 || receiver?.kind !== "object" || receiver.className !== cls.name ||
+                helper.returnType.kind !== "dyn" || helper.captures !== undefined || helper.classCaptures !== undefined) {
+                errors.push({ message: `class ${cls.name}: instance prototype helper must be a noncapturing (instance) => dyn function`, loc: cls.loc });
+            }
+        }
+        for (const symbol of cls.symbolFields ?? []) {
+            const global = mod.globals?.find((global) => global.id === symbol.globalId);
+            if (global?.type.kind !== "symbol" || !cls.fields.some((field) => field.name === symbol.field)) {
+                errors.push({ message: `class ${cls.name}: invalid symbol field metadata`, loc: cls.loc });
+            }
+        }
         const seen = new Set();
         for (const f of cls.fields) {
             if (seen.has(f.name)) {
@@ -1746,7 +1813,7 @@ export function validateModule(mod) {
             errors.push({ message: `class ${cls.name}: undeclared base "${cls.base}"`, loc: cls.loc });
             continue;
         }
-        if (base.localCaptures !== undefined && cls.localBaseCapture === undefined) {
+        if (base.localCaptures !== undefined && cls.localBaseCapture === undefined && cls.baseValueGlobal === undefined) {
             errors.push({ message: `class ${cls.name}: local base requires a captured constructor`, loc: cls.loc });
         }
         const seen = new Set([cls.name]);
@@ -2113,9 +2180,8 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
     if (isUnitType(fn.returnType)) {
         err(`return type is bare unit type ${fn.returnType.kind}`, fn.loc);
     }
-    // Caught (catch-binding) values are local-only by construction: they can
-    // never be parameters, returns, or captures (the frontend fences every
-    // escape; a caught anywhere else is frontend breakage).
+    // Exception snapshots may be captured, but are never public parameters
+    // or return values. Their payload crosses those boundaries explicitly.
     if (fn.returnType.kind === "caught")
         err("return type is caught", fn.loc);
     for (const p of fn.params) {
@@ -2133,8 +2199,6 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
             err(`capture local "${c.localId}" is not boxed`, fn.loc);
         else if (!typeEquals(local.type, c.type))
             err(`capture local "${c.localId}" has the wrong type`, fn.loc);
-        if (c.type.kind === "caught")
-            err(`capture "${c.name}" is caught-typed`, fn.loc);
     }
     if (fn.classCaptures !== undefined) {
         const self = fn.params[0];
@@ -2838,7 +2902,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                         err(`toString of unknown union ${e.operand.type.unionId}`, e.loc);
                     }
                     else if (!def.arms.every((a) => a.kind === "undefinedT" || a.kind === "nullT" ||
-                        a.kind === "string" || a.kind === "f64" || a.kind === "bool" ||
+                        a.kind === "string" || a.kind === "f64" || a.kind === "bigint" || a.kind === "bool" ||
                         (a.kind === "bytes" && a.elem === "u8"))) {
                         err("toString union operand has a non-stringable arm (frontend must fence)", e.loc);
                     }
@@ -2908,7 +2972,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                     if (want)
                         expectType(a, want, `regexIntrinsic ${e.method} arg ${i}`);
                 });
-                if (e.method === "match") {
+                if (e.method === "match" || e.method === "exec") {
                     // The `string[] | null` union (program-dependent id) — checked
                     // by arms, like the libCall case checks process.envGet.
                     const def = e.type.kind === "union" ? unions.get(e.type.unionId) : undefined;
@@ -4508,7 +4572,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
             return;
         if (checkLibEmitterCall(e, sig.result))
             return;
-        if (e.fn === "error.stack" || e.fn === "error.cause" || e.fn === "error.hasCause" || e.fn === "error.setCause" || e.fn === "error.deleteCause") {
+        if (e.fn === "error.stack" || e.fn === "error.cause" || e.fn === "error.hasCause" || e.fn === "error.setCause" || e.fn === "error.defineCause" || e.fn === "error.deleteCause") {
             const recv = e.args[0];
             let cls = recv?.type.kind === "object" ? classes.get(recv.type.className) : undefined;
             while (cls?.base)
@@ -5162,6 +5226,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
                 }
             }
         }
+        if (e.fn === "child.onSpawn") {
+            const cb = e.args[1];
+            if (!cb || cb.type.kind !== "func" || cb.type.params.length !== 0 || cb.type.ret.kind !== "void")
+                err("child.onSpawn callback must be () => void", e.loc);
+        }
         if (e.fn === "child.onExit" || e.fn === "child.onClose" || e.fn === "child.onError") {
             // The listener: a closure with no params, or exactly the
             // supported parameter shapes per event — exit takes (code:
@@ -5590,7 +5659,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
         return false;
     }
     function checkLibEmitterCall(e, result) {
-        if (e.fn.startsWith("emitter.") && e.fn !== "emitter.setDefaultMax" &&
+        if ((e.fn.startsWith("emitter.") || e.fn === "stream.onDyn") && e.fn !== "emitter.setDefaultMax" &&
             e.fn !== "emitter.setDefaultMaxChk" &&
             e.fn !== "emitter.getDefaultMax" && e.fn !== "emitter.checkListener") {
             // Receiver: an emitter-hierarchy object (the %EventEmitter class
@@ -5619,7 +5688,7 @@ function validateFunction(fn, functions, ffiByName, classes, records, unions, gl
             }
             // The chaining forms return the receiver's own static class.
             if (e.fn === "emitter.on" || e.fn === "emitter.off" ||
-                e.fn === "emitter.onDyn" || e.fn === "emitter.onFlex" || e.fn === "emitter.offDyn" ||
+                e.fn === "emitter.onDyn" || (e.fn === "emitter.onFlex" || e.fn === "stream.onDyn") || e.fn === "emitter.offDyn" ||
                 e.fn === "emitter.onData" || e.fn === "emitter.onDataDyn" ||
                 e.fn === "emitter.removeAll" || e.fn === "emitter.setMax" ||
                 e.fn === "emitter.setMaxChk") {