@esportsplus/typescript 0.32.0 → 0.33.1

package/build/{probe → guard}/kernel/ast.js

@@ -2,26 +2,33 @@ import * as ts from '../adapter.js';
 function shouldUnwrap(expr, options) {
     return (ts.isParenthesizedExpression(expr) ||
         (options.assertions === true &&
-            (ts.isAsExpression(expr) || ts.isNonNullExpression(expr))) ||
+            (ts.isAsExpression(expr) ||
+                ts.isNonNullExpression(expr) ||
+                ts.isSatisfiesExpression(expr))) ||
         (options.awaits === true && ts.isAwaitExpression(expr)));
 }
 const bodyOf = (node) => {
     return node.body;
 };
-const calleeSelectors = (callee) => {
-    let selectors = new Set();
-    if (ts.isIdentifier(callee)) {
-        selectors.add(callee.text);
-    }
-    else if (ts.isPropertyAccessExpression(callee)) {
-        let member = callee.name.text;
-        selectors.add(member);
-        if (ts.isIdentifier(callee.expression)) {
-            selectors.add(`${callee.expression.text}.${member}`);
-            selectors.add(`${callee.expression.text}#${member}`);
-        }
+const constituents = (type) => {
+    return ts.unionTypes(type) ?? [type];
+};
+const hasModifier = (node, kind) => {
+    const modifiers = node.modifiers;
+    return modifiers?.some((modifier) => modifier.kind === kind) ?? false;
+};
+const isAwaited = (call) => {
+    let child = call;
+    let parent = call.parent;
+    while (parent &&
+        (ts.isParenthesizedExpression(parent) ||
+            ts.isAsExpression(parent) ||
+            ts.isNonNullExpression(parent)) &&
+        parent.expression === child) {
+        child = parent;
+        parent = parent.parent;
     }
-    return selectors;
+    return parent !== undefined && ts.isAwaitExpression(parent);
 };
 const paramSymbols = (checker, fn) => {
     let symbols = new Map();
@@ -46,4 +53,4 @@ const unwrap = (expr, options = {}) => {
     }
     return unwrapped;
 };
-export { bodyOf, calleeSelectors, paramSymbols, unwrap };
+export { bodyOf, constituents, hasModifier, isAwaited, paramSymbols, unwrap };

package/build/guard/kernel/config.js

@@ -0,0 +1,93 @@
+import * as NodePath from 'node:path';
+import { readGuardConfig } from '../../tsconfig.js';
+import { stripJsonc } from '../../jsonc.js';
+const CHANNEL_NAMES = ['exceptions', 'resources', 'async'];
+const SEVERITIES = ['error', 'info', 'off', 'warn'];
+const OPTION_KEYS = {
+    async: [],
+    exceptions: ['report'],
+    resources: [],
+};
+function fail(message) {
+    throw new Error(`analyze config: ${message}`);
+}
+function absent(value) {
+    return value === undefined || value === null;
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseSeverity(value, channel) {
+    if (absent(value)) {
+        return 'error';
+    }
+    if (!SEVERITIES.includes(value)) {
+        fail(`${channel}.severity must be "error", "warn", "info", or "off"`);
+    }
+    return value;
+}
+function parseChannel(name, raw) {
+    if (!isPlainObject(raw)) {
+        fail(`${name} must be an object`);
+    }
+    const options = {};
+    for (const key of Object.keys(raw)) {
+        if (key === 'severity' || absent(raw[key])) {
+            continue;
+        }
+        if (!OPTION_KEYS[name].includes(key)) {
+            fail(`${name}.${key} is not a supported option`);
+        }
+        options[key] = raw[key];
+    }
+    return { severity: parseSeverity(raw['severity'], name), options };
+}
+function normalizeConfig(raw, projectRoot) {
+    if (!isPlainObject(raw)) {
+        fail(`root must be a JSON object`);
+    }
+    for (const key of Object.keys(raw)) {
+        if (absent(raw[key])) {
+            continue;
+        }
+        if (!CHANNEL_NAMES.includes(key)) {
+            fail(`unknown channel "${key}" (known: ${CHANNEL_NAMES.join(', ')})`);
+        }
+    }
+    const channels = {};
+    for (const name of CHANNEL_NAMES) {
+        channels[name] = absent(raw[name])
+            ? { severity: 'off', options: {} }
+            : parseChannel(name, raw[name]);
+    }
+    return {
+        projectRoot,
+        tsconfigPath: NodePath.join(projectRoot, 'tsconfig.json'),
+        channels,
+    };
+}
+function parseConfig(text, projectRoot) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stripJsonc(text));
+    }
+    catch (error) {
+        fail(`invalid JSONC: ${error.message}`);
+    }
+    return normalizeConfig(parsed, projectRoot);
+}
+function configFromObject(raw, projectRoot) {
+    return normalizeConfig((raw ?? {}), projectRoot);
+}
+function loadConfigFromTsconfig(tsconfigPath) {
+    const resolved = NodePath.resolve(tsconfigPath);
+    const guard = readGuardConfig(resolved);
+    if (!guard) {
+        return undefined;
+    }
+    return {
+        ...configFromObject(guard, NodePath.dirname(resolved)),
+        tsconfigPath: resolved,
+    };
+}
+export { configFromObject, loadConfigFromTsconfig, parseConfig };

package/build/guard/kernel/fixpoint.d.ts

@@ -0,0 +1,6 @@
+import type { Analysis, Channel, Diagnostic, SummaryStore } from './types.js';
+declare function runChannel<V>(analysis: Analysis, channel: Channel<V>, channelConfig: unknown, peers: ReadonlyMap<string, SummaryStore<unknown>>): {
+    store: SummaryStore<V>;
+    diagnostics: Diagnostic[];
+};
+export { runChannel };

package/build/{probe → guard}/kernel/fixpoint.js

@@ -66,14 +66,10 @@ function tarjanSccs(nodes, successors) {
     }
     return sccs;
 }
-function runChannel(analysis, channel, dispatch, channelConfig, peers) {
+function runChannel(analysis, channel, channelConfig, peers) {
     const graph = analysis.graph;
     const reached = graph.reachedFunctions();
-    const reachedById = new Map();
-    for (const fn of reached) {
-        reachedById.set(fn.id, fn);
-    }
-    const calleesOf = (fn) => graph.calleesOf(fn).filter((c) => reachedById.has(c.id));
+    const calleesOf = graph.calleesOf;
     const summaries = new Map();
     const bottomSummary = () => ({
         value: channel.bottom(),
@@ -83,9 +79,6 @@ function runChannel(analysis, channel, dispatch, channelConfig, peers) {
     const makeTransferContext = (fn) => ({
         checker: analysis.checker,
         fn,
-        dispatch,
-        channelConfig,
-        sinks: analysis.config.sinks,
         summaryOf,
         resolveCall: (call) => graph.resolveCall(call, channel.name),
         resolveCallFor: (peerChannel, call) => graph.resolveCall(call, peerChannel),
@@ -96,6 +89,12 @@ function runChannel(analysis, channel, dispatch, channelConfig, peers) {
         for (const fn of scc) {
             summaries.set(fn.id, bottomSummary());
         }
+        if (scc.length === 1 &&
+            !calleesOf(scc[0]).some((callee) => callee.id === scc[0].id)) {
+            const fn = scc[0];
+            summaries.set(fn.id, channel.transfer(makeTransferContext(fn)));
+            continue;
+        }
         let round = 0;
         for (;;) {
             round += 1;
@@ -136,41 +135,6 @@ function runChannel(analysis, channel, dispatch, channelConfig, peers) {
             }
         }
     }
-    const boundaries = graph.boundaries();
-    const pathToBoundary = (fn) => {
-        if (boundaries.has(fn.id)) {
-            return [fn];
-        }
-        const parent = new Map();
-        const visited = new Set([fn.id]);
-        const queue = [fn];
-        let head = 0;
-        while (head < queue.length) {
-            const cur = queue[head];
-            head += 1;
-            for (const caller of reverse.get(cur.id) ?? []) {
-                if (visited.has(caller.id)) {
-                    continue;
-                }
-                visited.add(caller.id);
-                parent.set(caller.id, cur);
-                if (boundaries.has(caller.id)) {
-                    const rev = [];
-                    let node = caller;
-                    while (node) {
-                        rev.push(node);
-                        if (node.id === fn.id) {
-                            break;
-                        }
-                        node = parent.get(node.id);
-                    }
-                    return rev.toReversed();
-                }
-                queue.push(caller);
-            }
-        }
-        return [fn];
-    };
     const roots = reached.filter((fn) => (reverse.get(fn.id) ?? []).length === 0);
     const diagnostics = [];
     const seen = new Set();
@@ -178,15 +142,11 @@ function runChannel(analysis, channel, dispatch, channelConfig, peers) {
         const ctx = {
             checker: analysis.checker,
             fn,
-            dispatch,
             channelConfig,
-            sinks: analysis.config.sinks,
-            isBoundary: boundaries.has(fn.id),
             summaryOf,
             resolveCall: (call) => graph.resolveCall(call, channel.name),
             resolveCallFor: (peerChannel, call) => graph.resolveCall(call, peerChannel),
             peerSummaryValue: (peerChannel, fnId) => peers.get(peerChannel)?.get(fnId).value,
-            pathToBoundary,
             roots: () => roots,
         };
         for (const d of channel.diagnose(ctx)) {

package/build/guard/kernel/graph.d.ts

@@ -0,0 +1,4 @@
+import * as ts from '../adapter.js';
+import type { CallGraph, OverlaySet } from './types.js';
+declare function buildCallGraph(program: ts.Program, checker: ts.TypeChecker, overlays: OverlaySet): CallGraph;
+export { buildCallGraph };

package/build/guard/kernel/graph.js

@@ -0,0 +1,268 @@
+import * as ts from '../adapter.js';
+import { hasModifier, unwrap } from './ast.js';
+import { isFunctionLike, makeFunctionInfo } from './ids.js';
+function buildCallGraph(program, checker, overlays) {
+    const sourceFiles = ts.getSourceFiles(program);
+    const analyzableFiles = new Set(entryFiles());
+    const reached = new Map();
+    const worklist = [];
+    const coreCache = new Map();
+    const resolutionCache = new Map();
+    const callsCache = new Map();
+    const calleesCache = new Map();
+    function isAnalyzable(node) {
+        const sf = node.getSourceFile();
+        return analyzableFiles.has(sf) && node.body != null;
+    }
+    function intern(node) {
+        if (!isAnalyzable(node)) {
+            return undefined;
+        }
+        const existing = reached.get(node);
+        if (existing) {
+            return existing;
+        }
+        const info = makeFunctionInfo(node, node.getSourceFile());
+        reached.set(node, info);
+        worklist.push(info);
+        return info;
+    }
+    function calleeSymbol(call) {
+        let sym = checker.getSymbolAtLocation(call.expression);
+        if (sym && sym.flags & ts.SymbolFlags.Alias) {
+            sym = checker.getAliasedSymbol(sym);
+        }
+        return sym;
+    }
+    function functionLikesFromSymbol(sym, isNew) {
+        const out = [];
+        for (const decl of ts.symbolDeclarations(sym)) {
+            if (isFunctionLike(decl)) {
+                out.push(decl);
+                continue;
+            }
+            if (ts.isVariableDeclaration(decl) &&
+                decl.initializer &&
+                isFunctionLike(decl.initializer)) {
+                out.push(decl.initializer);
+                continue;
+            }
+            if (isNew && ts.isClassLike(decl)) {
+                const members = decl.members ?? [];
+                for (const member of members) {
+                    if (ts.isConstructorDeclaration(member)) {
+                        out.push(member);
+                    }
+                }
+            }
+        }
+        return out;
+    }
+    function argExpressions(call) {
+        return call.arguments ? Array.from(call.arguments) : [];
+    }
+    function computeCore(call) {
+        const isNew = ts.isNewExpression(call);
+        const sym = calleeSymbol(call);
+        let functionArgs;
+        const resolveFunctionArgs = () => {
+            if (functionArgs) {
+                return functionArgs;
+            }
+            const resolved = new Map();
+            functionArgs = resolved;
+            argExpressions(call).forEach((arg, index) => {
+                const infos = resolveFunctionValue(arg);
+                if (infos.length > 0) {
+                    resolved.set(index, infos);
+                }
+            });
+            return functionArgs;
+        };
+        if (!sym) {
+            return {
+                symbol: undefined,
+                targets: [],
+                functionArgs: resolveFunctionArgs,
+                unresolved: true,
+            };
+        }
+        const fns = functionLikesFromSymbol(sym, isNew);
+        const seen = new Set();
+        const targets = [];
+        for (const fn of fns) {
+            const info = intern(fn);
+            if (info && !seen.has(info.id)) {
+                seen.add(info.id);
+                targets.push(info);
+            }
+        }
+        if (targets.length > 0) {
+            return { symbol: sym, targets, functionArgs: resolveFunctionArgs, unresolved: false };
+        }
+        if (fns.length === 0) {
+            return { symbol: sym, targets: [], functionArgs: resolveFunctionArgs, unresolved: true };
+        }
+        if (fns.some((fn) => hasModifier(fn, ts.SyntaxKind.AbstractKeyword))) {
+            return { symbol: sym, targets: [], functionArgs: resolveFunctionArgs, unresolved: true };
+        }
+        return { symbol: sym, targets: [], functionArgs: resolveFunctionArgs, unresolved: false };
+    }
+    function getCore(call) {
+        let core = coreCache.get(call);
+        if (!core) {
+            core = computeCore(call);
+            coreCache.set(call, core);
+        }
+        return core;
+    }
+    function resolveFunctionValue(expr) {
+        const e = unwrap(expr, { assertions: true });
+        if (isFunctionLike(e)) {
+            const info = intern(e);
+            return info ? [info] : [];
+        }
+        if (ts.isIdentifier(e) ||
+            ts.isPropertyAccessExpression(e) ||
+            ts.isElementAccessExpression(e)) {
+            let sym = checker.getSymbolAtLocation(e);
+            if (sym && sym.flags & ts.SymbolFlags.Alias) {
+                sym = checker.getAliasedSymbol(sym);
+            }
+            if (!sym) {
+                return [];
+            }
+            const seen = new Set();
+            const out = [];
+            for (const fn of functionLikesFromSymbol(sym, false)) {
+                const info = intern(fn);
+                if (info && !seen.has(info.id)) {
+                    seen.add(info.id);
+                    out.push(info);
+                }
+            }
+            return out;
+        }
+        return [];
+    }
+    function callsIn(fn) {
+        const cached = callsCache.get(fn.id);
+        if (cached) {
+            return cached;
+        }
+        const calls = [];
+        const visit = (node) => {
+            if (node !== fn.node && isFunctionLike(node)) {
+                return;
+            }
+            if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
+                calls.push(node);
+            }
+            ts.forEachChild(node, visit);
+        };
+        const body = fn.node.body;
+        if (body) {
+            visit(body);
+        }
+        for (const param of fn.node.parameters) {
+            if (param.initializer) {
+                visit(param.initializer);
+            }
+        }
+        callsCache.set(fn.id, calls);
+        return calls;
+    }
+    function allFunctionLikesIn(sf) {
+        const out = [];
+        const visit = (node) => {
+            if (isFunctionLike(node) &&
+                (!ts.isFunctionDeclaration(node) || node.body)) {
+                out.push(node);
+            }
+            ts.forEachChild(node, visit);
+        };
+        ts.forEachChild(sf, visit);
+        return out;
+    }
+    function entryFiles() {
+        return sourceFiles.filter((sf) => !sf.isDeclarationFile &&
+            !sf.fileName.replace(/\\/g, '/').includes('/node_modules/'));
+    }
+    for (const sf of entryFiles()) {
+        for (const node of allFunctionLikesIn(sf)) {
+            intern(node);
+        }
+    }
+    for (let workIndex = 0; workIndex < worklist.length; workIndex++) {
+        const fn = worklist[workIndex];
+        for (const call of callsIn(fn)) {
+            getCore(call);
+        }
+    }
+    const reachedList = Array.from(reached.values());
+    function resolveCall(call, channel) {
+        let cached = resolutionCache.get(call)?.get(channel);
+        if (cached) {
+            return cached;
+        }
+        const core = getCore(call);
+        let result;
+        if (core.targets.length > 0) {
+            result = {
+                targets: core.targets,
+                overlay: undefined,
+                get functionArgs() { return core.functionArgs(); },
+                unresolved: false,
+            };
+        }
+        else {
+            const overlay = core.symbol
+                ? overlays.lookup(core.symbol, channel)
+                : undefined;
+            result = overlay ? {
+                targets: [],
+                overlay,
+                get functionArgs() { return core.functionArgs(); },
+                unresolved: false,
+            } : {
+                targets: [],
+                overlay: undefined,
+                get functionArgs() { return core.functionArgs(); },
+                unresolved: core.unresolved,
+            };
+        }
+        let resolutions = resolutionCache.get(call);
+        if (!resolutions) {
+            resolutions = new Map();
+            resolutionCache.set(call, resolutions);
+        }
+        resolutions.set(channel, result);
+        return result;
+    }
+    function calleesOf(fn) {
+        const cached = calleesCache.get(fn.id);
+        if (cached) {
+            return cached;
+        }
+        const seen = new Set();
+        const out = [];
+        for (const call of callsIn(fn)) {
+            for (const target of getCore(call).targets) {
+                if (reached.has(target.node) && !seen.has(target.id)) {
+                    seen.add(target.id);
+                    out.push(target);
+                }
+            }
+        }
+        calleesCache.set(fn.id, out);
+        return out;
+    }
+    return {
+        reachedFunctions() {
+            return reachedList;
+        },
+        calleesOf,
+        resolveCall,
+    };
+}
+export { buildCallGraph };

package/build/{probe → guard}/kernel/ids.d.ts

@@ -1,8 +1,7 @@
 import * as ts from '../adapter.js';
 import type { FunctionInfo, FunctionLike, SourceLocation } from './types.js';
+declare const FUNCTION_LIKE_KINDS: Set<ts.SyntaxKind>;
 declare function isFunctionLike(node: ts.Node): node is FunctionLike;
-declare function functionName(node: FunctionLike): string;
-declare function functionId(node: FunctionLike, sourceFile: ts.SourceFile): string;
 declare function makeFunctionInfo(node: FunctionLike, sourceFile: ts.SourceFile): FunctionInfo;
 declare function locationOf(node: ts.Node, sourceFile: ts.SourceFile): SourceLocation;
-export { functionId, functionName, isFunctionLike, locationOf, makeFunctionInfo };
+export { FUNCTION_LIKE_KINDS, isFunctionLike, locationOf, makeFunctionInfo };

package/build/{probe → guard}/kernel/ids.js

@@ -39,17 +39,12 @@ function functionId(node, sourceFile) {
     return `${sourceFile.fileName}:${node.getStart(sourceFile)}`;
 }
 function makeFunctionInfo(node, sourceFile) {
-    const nameNode = node.name;
-    const pos = nameNode
-        ? nameNode.getStart(sourceFile)
-        : node.getStart(sourceFile);
     return {
         id: functionId(node, sourceFile),
         node,
         sourceFile,
         name: functionName(node),
         fileName: sourceFile.fileName,
-        pos,
     };
 }
 function locationOf(node, sourceFile) {
@@ -63,4 +58,4 @@ function locationOf(node, sourceFile) {
         end: node.getEnd(),
     };
 }
-export { functionId, functionName, isFunctionLike, locationOf, makeFunctionInfo };
+export { FUNCTION_LIKE_KINDS, isFunctionLike, locationOf, makeFunctionInfo };

package/build/{probe → guard}/kernel/types.d.ts

@@ -6,13 +6,12 @@ type FunctionInfo = {
     readonly sourceFile: ts.SourceFile;
     readonly name: string;
     readonly fileName: string;
-    readonly pos: number;
 };
 type Summary<V> = {
     readonly value: V;
     readonly fromCallbacks: ReadonlySet<number>;
 };
-export type Dispatch = 'optimist' | 'pessimist';
+export type Severity = 'error' | 'info' | 'off' | 'warn';
 type CalleeResolution = {
     readonly targets: ReadonlyArray<FunctionInfo>;
     readonly overlay: OverlayLookup | undefined;
@@ -27,9 +26,6 @@ type OverlayLookup = {
 type TransferContext<V> = {
     readonly checker: ts.TypeChecker;
     readonly fn: FunctionInfo;
-    readonly dispatch: Dispatch;
-    readonly channelConfig: unknown;
-    readonly sinks: ReadonlyArray<SinkConfig>;
     summaryOf(fn: FunctionInfo): Summary<V>;
     resolveCall(call: ts.CallExpression | ts.NewExpression): CalleeResolution;
     resolveCallFor(channel: string, call: ts.CallExpression | ts.NewExpression): CalleeResolution;
@@ -38,15 +34,11 @@ type TransferContext<V> = {
 type DiagnoseContext<V> = {
     readonly checker: ts.TypeChecker;
     readonly fn: FunctionInfo;
-    readonly dispatch: Dispatch;
     readonly channelConfig: unknown;
-    readonly sinks: ReadonlyArray<SinkConfig>;
-    readonly isBoundary: boolean;
     summaryOf(fn: FunctionInfo): Summary<V>;
     resolveCall(call: ts.CallExpression | ts.NewExpression): CalleeResolution;
     resolveCallFor(channel: string, call: ts.CallExpression | ts.NewExpression): CalleeResolution;
     peerSummaryValue(channel: string, fnId: string): unknown;
-    pathToBoundary(fn: FunctionInfo): ReadonlyArray<FunctionInfo>;
     roots(): ReadonlyArray<FunctionInfo>;
 };
 type Channel<V> = {
@@ -86,49 +78,28 @@ type Diagnostic = {
     readonly related: ReadonlyArray<DiagnosticRelated>;
     readonly fixes?: ReadonlyArray<DiagnosticFix>;
 };
-type HandlerBoundary = {
-    readonly callee: string;
-    readonly callbackArgs: ReadonlyArray<number>;
-};
-type SinkConfig = {
-    readonly callee: string;
-    readonly absorbs: ReadonlyArray<string> | undefined;
-};
 type ChannelConfig = {
-    readonly enabled: boolean;
-    readonly dispatch: Dispatch;
+    readonly severity: Severity;
     readonly options: unknown;
 };
 type AnalyzeConfig = {
     readonly projectRoot: string;
     readonly tsconfigPath: string;
-    readonly entryPoints: ReadonlyArray<string>;
-    readonly handlerBoundaries: ReadonlyArray<HandlerBoundary>;
-    readonly sinks: ReadonlyArray<SinkConfig>;
-    readonly presets: ReadonlyArray<string>;
-    readonly overlays: ReadonlyArray<string>;
     readonly channels: Readonly<Record<string, ChannelConfig>>;
-    readonly failOnFindings: boolean;
-    readonly severity: 'error' | 'warning';
 };
 type OverlaySet = {
     lookup(symbol: ts.Symbol, channel: string): OverlayLookup | undefined;
 };
 type CallGraph = {
     reachedFunctions(): ReadonlyArray<FunctionInfo>;
-    boundaries(): ReadonlySet<string>;
     calleesOf(fn: FunctionInfo): ReadonlyArray<FunctionInfo>;
     resolveCall(call: ts.CallExpression | ts.NewExpression, channel: string): CalleeResolution;
-    resolveFunctionValue(expr: ts.Expression): ReadonlyArray<FunctionInfo>;
 };
 type SummaryStore<V> = {
     get(id: string): Summary<V>;
 };
 type Analysis = {
-    readonly program: ts.Program;
     readonly checker: ts.TypeChecker;
-    readonly config: AnalyzeConfig;
-    readonly overlays: OverlaySet;
     readonly graph: CallGraph;
 };
-export { type Analysis, type AnalyzeConfig, type CallGraph, type CalleeResolution, type Channel, type ChannelConfig, type DiagnoseContext, type Diagnostic, type DiagnosticEdit, type DiagnosticFix, type DiagnosticRelated, type FunctionInfo, type HandlerBoundary, type OverlayLookup, type OverlaySet, type SinkConfig, type SourceLocation, type Summary, type SummaryStore, type TransferContext };
+export { type Analysis, type AnalyzeConfig, type CallGraph, type CalleeResolution, type Channel, type ChannelConfig, type DiagnoseContext, type Diagnostic, type DiagnosticEdit, type DiagnosticFix, type DiagnosticRelated, type FunctionInfo, type OverlayLookup, type OverlaySet, type SourceLocation, type Summary, type SummaryStore, type TransferContext };

package/build/{probe → guard}/overlay/base/async.jsonc

@@ -5,7 +5,7 @@
 {
   "overlay": {
     "async": {
-      "lib.dom": {
+      "global": {
         "fetch": { "cancellable": true }
       }
     }