@windrun-huaiin/third-ui 13.1.4 → 14.0.0

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/utils/grammar-utils.mjs

@@ -1,483 +0,0 @@
-import { assertUnreachable } from './errors.mjs';
-import { isTerminalRule, isInferredType, isAction, isAbstractParserRule, isParserRule, isRuleCall, isTerminalAlternatives, isTerminalGroup, isCharacterRange, isTerminalRuleCall, isNegatedToken, isUntilToken, isRegexToken, isWildcard, isAssignment, isSimpleType, isKeyword, isInterface, isType, isReturnType, isInfixRule } from '../languages/generated/ast.mjs';
-import { isCompositeCstNode } from '../syntax-tree.mjs';
-import { streamAllContents, getContainerOfType } from './ast-utils.mjs';
-import { streamCst } from './cst-utils.mjs';
-import { escapeRegExp, isWhitespace } from './regexp-utils.mjs';
-
-/******************************************************************************
- * Copyright 2021-2022 TypeFox GmbH
- * This program and the accompanying materials are made available under the
- * terms of the MIT License, which is available in the project root.
- ******************************************************************************/
-/**
- * Returns the entry rule of the given grammar, if any. If the grammar file does not contain an entry rule,
- * the result is `undefined`.
- */
-function getEntryRule(grammar) {
-    return grammar.rules.find(e => isParserRule(e) && e.entry);
-}
-/**
- * Returns all hidden terminal rules of the given grammar, if any.
- */
-function getHiddenRules(grammar) {
-    return grammar.rules.filter(e => isTerminalRule(e) && e.hidden);
-}
-/**
- * Returns all rules that can be reached from the topmost rules of the specified grammar (entry and hidden terminal rules).
- *
- * @param grammar The grammar that contains all rules
- * @param allTerminals Whether or not to include terminals that are referenced only by other terminals
- * @returns A list of referenced parser and terminal rules. If the grammar contains no entry rule,
- *      this function returns all rules of the specified grammar.
- */
-function getAllReachableRules(grammar, allTerminals) {
-    const ruleNames = new Set();
-    const entryRule = getEntryRule(grammar);
-    if (!entryRule) {
-        return new Set(grammar.rules);
-    }
-    const topMostRules = [entryRule].concat(getHiddenRules(grammar));
-    for (const rule of topMostRules) {
-        ruleDfs(rule, ruleNames, allTerminals);
-    }
-    const rules = new Set();
-    for (const rule of grammar.rules) {
-        if (ruleNames.has(rule.name) || (isTerminalRule(rule) && rule.hidden)) {
-            rules.add(rule);
-        }
-    }
-    return rules;
-}
-function ruleDfs(rule, visitedSet, allTerminals) {
-    visitedSet.add(rule.name);
-    streamAllContents(rule).forEach(node => {
-        if (isRuleCall(node) || (allTerminals)) {
-            const refRule = node.rule.ref;
-            if (refRule && !visitedSet.has(refRule.name)) {
-                ruleDfs(refRule, visitedSet, allTerminals);
-            }
-        }
-    });
-}
-/**
- * Determines the grammar expression used to parse a cross-reference (usually a reference to a terminal rule).
- * A cross-reference can declare this expression explicitly in the form `[Type : Terminal]`, but if `Terminal`
- * is omitted, this function attempts to infer it from the name of the referenced `Type` (using `findNameAssignment`).
- *
- * Returns the grammar expression used to parse the given cross-reference, or `undefined` if it is not declared
- * and cannot be inferred.
- */
-function getCrossReferenceTerminal(crossRef) {
-    if (crossRef.terminal) {
-        return crossRef.terminal;
-    }
-    else if (crossRef.type.ref) {
-        const nameAssigment = findNameAssignment(crossRef.type.ref);
-        return nameAssigment?.terminal;
-    }
-    return undefined;
-}
-/**
- * Determines whether the given terminal rule represents a comment. This is true if the rule is marked
- * as `hidden` and it does not match white space. This means every hidden token (i.e. excluded from the AST)
- * that contains visible characters is considered a comment.
- */
-function isCommentTerminal(terminalRule) {
-    return terminalRule.hidden && !isWhitespace(terminalRegex(terminalRule));
-}
-/**
- * Find all CST nodes within the given node that contribute to the specified property.
- *
- * @param node A CST node in which to look for property assignments. If this is undefined, the result is an empty array.
- * @param property A property name of the constructed AST node. If this is undefined, the result is an empty array.
- */
-function findNodesForProperty(node, property) {
-    if (!node || !property) {
-        return [];
-    }
-    return findNodesForPropertyInternal(node, property, node.astNode, true);
-}
-/**
- * Find a single CST node within the given node that contributes to the specified property.
- *
- * @param node A CST node in which to look for property assignments. If this is undefined, the result is `undefined`.
- * @param property A property name of the constructed AST node. If this is undefined, the result is `undefined`.
- * @param index If no index is specified or the index is less than zero, the first found node is returned. If the
- *        specified index exceeds the number of assignments to the property, the last found node is returned. Otherwise,
- *        the node with the specified index is returned.
- */
-function findNodeForProperty(node, property, index) {
-    if (!node || !property) {
-        return undefined;
-    }
-    const nodes = findNodesForPropertyInternal(node, property, node.astNode, true);
-    if (nodes.length === 0) {
-        return undefined;
-    }
-    if (index !== undefined) {
-        index = Math.max(0, Math.min(index, nodes.length - 1));
-    }
-    else {
-        index = 0;
-    }
-    return nodes[index];
-}
-function findNodesForPropertyInternal(node, property, element, first) {
-    if (!first) {
-        const nodeFeature = getContainerOfType(node.grammarSource, isAssignment);
-        if (nodeFeature && nodeFeature.feature === property) {
-            return [node];
-        }
-    }
-    if (isCompositeCstNode(node) && node.astNode === element) {
-        return node.content.flatMap(e => findNodesForPropertyInternal(e, property, element, false));
-    }
-    return [];
-}
-/**
- * Find a single CST node within the given node that corresponds to the specified keyword.
- *
- * @param node A CST node in which to look for keywords. If this is undefined, the result is `undefined`.
- * @param keyword A keyword as specified in the grammar.
- * @param index If no index is specified or the index is less than zero, the first found node is returned. If the
- *        specified index exceeds the number of keyword occurrences, the last found node is returned. Otherwise,
- *        the node with the specified index is returned.
- */
-function findNodeForKeyword(node, keyword, index) {
-    if (!node) {
-        return undefined;
-    }
-    const nodes = findNodesForKeywordInternal(node, keyword, node?.astNode);
-    if (nodes.length === 0) {
-        return undefined;
-    }
-    if (index !== undefined) {
-        index = Math.max(0, Math.min(index, nodes.length - 1));
-    }
-    else {
-        index = 0;
-    }
-    return nodes[index];
-}
-function findNodesForKeywordInternal(node, keyword, element) {
-    if (node.astNode !== element) {
-        return [];
-    }
-    if (isKeyword(node.grammarSource) && node.grammarSource.value === keyword) {
-        return [node];
-    }
-    const treeIterator = streamCst(node).iterator();
-    let result;
-    const keywordNodes = [];
-    do {
-        result = treeIterator.next();
-        if (!result.done) {
-            const childNode = result.value;
-            if (childNode.astNode === element) {
-                if (isKeyword(childNode.grammarSource) && childNode.grammarSource.value === keyword) {
-                    keywordNodes.push(childNode);
-                }
-            }
-            else {
-                treeIterator.prune();
-            }
-        }
-    } while (!result.done);
-    return keywordNodes;
-}
-/**
- * If the given CST node was parsed in the context of a property assignment, the respective `Assignment` grammar
- * node is returned. If no assignment is found, the result is `undefined`.
- *
- * @param cstNode A CST node for which to find a property assignment.
- */
-function findAssignment(cstNode) {
-    const astNode = cstNode.astNode;
-    // Only search until the ast node of the parent cst node is no longer the original ast node
-    // This would make us jump to a preceding rule call, which contains only unrelated assignments
-    while (astNode === cstNode.container?.astNode) {
-        const assignment = getContainerOfType(cstNode.grammarSource, isAssignment);
-        if (assignment) {
-            return assignment;
-        }
-        cstNode = cstNode.container;
-    }
-    return undefined;
-}
-/**
- * Find an assignment to the `name` property for the given grammar type. This requires the `type` to be inferred
- * from a parser rule, and that rule must contain an assignment to the `name` property. In all other cases,
- * this function returns `undefined`.
- */
-function findNameAssignment(type) {
-    let startNode = type;
-    if (isInferredType(startNode)) {
-        // for inferred types, the location to start searching for the name-assignment is different
-        if (isAction(startNode.$container)) {
-            // a type which is explicitly inferred by an action: investigate the sibling of the Action node, i.e. start searching at the Action's parent
-            startNode = startNode.$container.$container;
-        }
-        else if (isAbstractParserRule(startNode.$container)) {
-            // investigate the parser rule with the explicitly inferred type
-            startNode = startNode.$container;
-        }
-        else {
-            assertUnreachable(startNode.$container);
-        }
-    }
-    return findNameAssignmentInternal(type, startNode, new Map());
-}
-function findNameAssignmentInternal(type, startNode, cache) {
-    // the cache is only required to prevent infinite loops
-    function go(node, refType) {
-        let childAssignment = undefined;
-        const parentAssignment = getContainerOfType(node, isAssignment);
-        // No parent assignment implies unassigned rule call
-        if (!parentAssignment) {
-            childAssignment = findNameAssignmentInternal(refType, refType, cache);
-        }
-        cache.set(type, childAssignment);
-        return childAssignment;
-    }
-    if (cache.has(type)) {
-        return cache.get(type);
-    }
-    cache.set(type, undefined);
-    for (const node of streamAllContents(startNode)) {
-        if (isAssignment(node) && node.feature.toLowerCase() === 'name') {
-            cache.set(type, node);
-            return node;
-        }
-        else if (isRuleCall(node) && isParserRule(node.rule.ref)) {
-            return go(node, node.rule.ref);
-        }
-        else if (isSimpleType(node) && node.typeRef?.ref) {
-            return go(node, node.typeRef.ref);
-        }
-    }
-    return undefined;
-}
-/**
- * Determines whether the given parser rule is a _data type rule_, meaning that it has a
- * primitive return type like `number`, `boolean`, etc.
- */
-function isDataTypeRule(rule) {
-    return isDataTypeRuleInternal(rule, new Set());
-}
-function isDataTypeRuleInternal(rule, visited) {
-    if (visited.has(rule)) {
-        return true;
-    }
-    else {
-        visited.add(rule);
-    }
-    for (const node of streamAllContents(rule)) {
-        if (isRuleCall(node)) {
-            if (!node.rule.ref) {
-                // RuleCall to unresolved rule. Don't assume `rule` is a DataType rule.
-                return false;
-            }
-            if (isParserRule(node.rule.ref) && !isDataTypeRuleInternal(node.rule.ref, visited)) {
-                return false;
-            }
-            if (isInfixRule(node.rule.ref)) {
-                return false;
-            }
-        }
-        else if (isAssignment(node)) {
-            return false;
-        }
-        else if (isAction(node)) {
-            return false;
-        }
-    }
-    return Boolean(rule.definition);
-}
-function getExplicitRuleType(rule) {
-    if (isTerminalRule(rule)) {
-        return undefined;
-    }
-    if (rule.inferredType) {
-        return rule.inferredType.name;
-    }
-    else if (rule.dataType) {
-        return rule.dataType;
-    }
-    else if (rule.returnType) {
-        const refType = rule.returnType.ref;
-        if (refType) {
-            return refType.name;
-        }
-    }
-    return undefined;
-}
-function getTypeName(type) {
-    if (isAbstractParserRule(type)) {
-        return isParserRule(type) && isDataTypeRule(type) ? type.name : getExplicitRuleType(type) ?? type.name;
-    }
-    else if (isInterface(type) || isType(type) || isReturnType(type)) {
-        return type.name;
-    }
-    else if (isAction(type)) {
-        const actionType = getActionType(type);
-        if (actionType) {
-            return actionType;
-        }
-    }
-    else if (isInferredType(type)) {
-        return type.name;
-    }
-    throw new Error('Cannot get name of Unknown Type');
-}
-function getActionType(action) {
-    if (action.inferredType) {
-        return action.inferredType.name;
-    }
-    else if (action.type?.ref) {
-        return getTypeName(action.type.ref);
-    }
-    return undefined; // not inferring and not referencing a valid type
-}
-/**
- * This function is used at runtime to get the actual type of the values produced by the given rule at runtime.
- * For data type rules, the name of the declared return type of the rule is returned (if any),
- * e.g. "INT_value returns number: MY_INT;" returns "number".
- * @param rule the given rule
- * @returns the name of the type of the produced values of the rule at runtime
- */
-function getRuleType(rule) {
-    if (isTerminalRule(rule)) {
-        return rule.type?.name ?? 'string';
-    }
-    else {
-        return getExplicitRuleType(rule) ?? rule.name;
-    }
-}
-function terminalRegex(terminalRule) {
-    const flags = {
-        s: false,
-        i: false,
-        u: false
-    };
-    const source = abstractElementToRegex(terminalRule.definition, flags);
-    const flagText = Object.entries(flags).filter(([, value]) => value).map(([name]) => name).join('');
-    return new RegExp(source, flagText);
-}
-// Using [\s\S]* allows to match everything, compared to . which doesn't match line terminators
-const WILDCARD = /[\s\S]/.source;
-function abstractElementToRegex(element, flags) {
-    if (isTerminalAlternatives(element)) {
-        return terminalAlternativesToRegex(element);
-    }
-    else if (isTerminalGroup(element)) {
-        return terminalGroupToRegex(element);
-    }
-    else if (isCharacterRange(element)) {
-        return characterRangeToRegex(element);
-    }
-    else if (isTerminalRuleCall(element)) {
-        const rule = element.rule.ref;
-        if (!rule) {
-            throw new Error('Missing rule reference.');
-        }
-        return withCardinality(abstractElementToRegex(rule.definition), {
-            cardinality: element.cardinality,
-            lookahead: element.lookahead,
-            parenthesized: element.parenthesized
-        });
-    }
-    else if (isNegatedToken(element)) {
-        return negateTokenToRegex(element);
-    }
-    else if (isUntilToken(element)) {
-        return untilTokenToRegex(element);
-    }
-    else if (isRegexToken(element)) {
-        const lastSlash = element.regex.lastIndexOf('/');
-        const source = element.regex.substring(1, lastSlash);
-        const regexFlags = element.regex.substring(lastSlash + 1);
-        if (flags) {
-            flags.i = regexFlags.includes('i');
-            flags.s = regexFlags.includes('s');
-            flags.u = regexFlags.includes('u');
-        }
-        return withCardinality(source, {
-            cardinality: element.cardinality,
-            lookahead: element.lookahead,
-            parenthesized: element.parenthesized,
-            wrap: false
-        });
-    }
-    else if (isWildcard(element)) {
-        return withCardinality(WILDCARD, {
-            cardinality: element.cardinality,
-            lookahead: element.lookahead,
-            parenthesized: element.parenthesized
-        });
-    }
-    else {
-        throw new Error(`Invalid terminal element: ${element?.$type}, ${element?.$cstNode?.text}`);
-    }
-}
-function terminalAlternativesToRegex(alternatives) {
-    return withCardinality(alternatives.elements.map(e => abstractElementToRegex(e)).join('|'), {
-        cardinality: alternatives.cardinality,
-        lookahead: alternatives.lookahead,
-        parenthesized: alternatives.parenthesized,
-        wrap: false // wrapping is not required for top level alternatives, and nested alternatives are already parenthesized according to the grammar
-    });
-}
-function terminalGroupToRegex(group) {
-    return withCardinality(group.elements.map(e => abstractElementToRegex(e)).join(''), {
-        cardinality: group.cardinality,
-        lookahead: group.lookahead,
-        parenthesized: group.parenthesized,
-        wrap: false // wrapping is not required for top level group, and nested group are already parenthesized according to the grammar
-    });
-}
-function untilTokenToRegex(until) {
-    return withCardinality(`${WILDCARD}*?${abstractElementToRegex(until.terminal)}`, {
-        cardinality: until.cardinality,
-        lookahead: until.lookahead,
-        parenthesized: until.parenthesized
-    });
-}
-function negateTokenToRegex(negate) {
-    return withCardinality(`(?!${abstractElementToRegex(negate.terminal)})${WILDCARD}*?`, {
-        cardinality: negate.cardinality,
-        lookahead: negate.lookahead,
-        parenthesized: negate.parenthesized
-    });
-}
-function characterRangeToRegex(range) {
-    if (range.right) {
-        return withCardinality(`[${keywordToRegex(range.left)}-${keywordToRegex(range.right)}]`, {
-            cardinality: range.cardinality,
-            lookahead: range.lookahead,
-            parenthesized: range.parenthesized,
-            wrap: false
-        });
-    }
-    return withCardinality(keywordToRegex(range.left), {
-        cardinality: range.cardinality,
-        lookahead: range.lookahead,
-        parenthesized: range.parenthesized,
-        wrap: false
-    });
-}
-function keywordToRegex(keyword) {
-    return escapeRegExp(keyword.value);
-}
-function withCardinality(regex, options) {
-    if (options.parenthesized || options.lookahead || options.wrap !== false) {
-        const groupConfig = options.lookahead ?? (options.parenthesized ? '' : '?:');
-        regex = `(${groupConfig}${regex})`;
-    }
-    if (options.cardinality) {
-        return `${regex}${options.cardinality}`;
-    }
-    return regex;
-}
-
-export { findAssignment, findNameAssignment, findNodeForKeyword, findNodeForProperty, findNodesForKeywordInternal, findNodesForProperty, getActionType, getAllReachableRules, getCrossReferenceTerminal, getEntryRule, getExplicitRuleType, getHiddenRules, getRuleType, getTypeName, isCommentTerminal, isDataTypeRule, terminalRegex };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/utils/promise-utils.js

@@ -1,101 +0,0 @@
-'use strict';
-
-var cancellation = require('../../../../../../../_virtual/cancellation.js');
-
-/******************************************************************************
- * Copyright 2021 TypeFox GmbH
- * This program and the accompanying materials are made available under the
- * terms of the MIT License, which is available in the project root.
- ******************************************************************************/
-/**
- * Delays the execution of the current code to the next tick of the event loop.
- * Don't call this method directly in a tight loop to prevent too many promises from being created.
- */
-function delayNextTick() {
-    return new Promise(resolve => {
-        // In case we are running in a non-node environment, `setImmediate` isn't available.
-        // Using `setTimeout` of the browser API accomplishes the same result.
-        if (typeof setImmediate === 'undefined') {
-            setTimeout(resolve, 0);
-        }
-        else {
-            setImmediate(resolve);
-        }
-    });
-}
-let lastTick = 0;
-let globalInterruptionPeriod = 10;
-/**
- * Reset the global interruption period and create a cancellation token source.
- */
-function startCancelableOperation() {
-    lastTick = performance.now();
-    return new cancellation.cancellationExports.CancellationTokenSource();
-}
-/**
- * This symbol may be thrown in an asynchronous context by any Langium service that receives
- * a `CancellationToken`. This means that the promise returned by such a service is rejected with
- * this symbol as rejection reason.
- */
-const OperationCancelled = Symbol('OperationCancelled');
-/**
- * Use this in a `catch` block to check whether the thrown object indicates that the operation
- * has been cancelled.
- */
-function isOperationCancelled(err) {
-    return err === OperationCancelled;
-}
-/**
- * This function does two things:
- *  1. Check the elapsed time since the last call to this function or to `startCancelableOperation`. If the predefined
- *     period (configured with `setInterruptionPeriod`) is exceeded, execution is delayed with `delayNextTick`.
- *  2. If the predefined period is not met yet or execution is resumed after an interruption, the given cancellation
- *     token is checked, and if cancellation is requested, `OperationCanceled` is thrown.
- *
- * All services in Langium that receive a `CancellationToken` may potentially call this function, so the
- * `CancellationToken` must be caught (with an `async` try-catch block or a `catch` callback attached to
- * the promise) to avoid that event being exposed as an error.
- */
-async function interruptAndCheck(token) {
-    if (token === cancellation.cancellationExports.CancellationToken.None) {
-        // Early exit in case cancellation was disabled by the caller
-        return;
-    }
-    const current = performance.now();
-    if (current - lastTick >= globalInterruptionPeriod) {
-        lastTick = current;
-        await delayNextTick();
-        // prevent calling delayNextTick every iteration of loop
-        // where delayNextTick takes up the majority or all of the
-        // globalInterruptionPeriod itself
-        lastTick = performance.now();
-    }
-    if (token.isCancellationRequested) {
-        throw OperationCancelled;
-    }
-}
-/**
- * Simple implementation of the deferred pattern.
- * An object that exposes a promise and functions to resolve and reject it.
- */
-class Deferred {
-    constructor() {
-        this.promise = new Promise((resolve, reject) => {
-            this.resolve = (arg) => {
-                resolve(arg);
-                return this;
-            };
-            this.reject = (err) => {
-                reject(err);
-                return this;
-            };
-        });
-    }
-}
-
-exports.Deferred = Deferred;
-exports.OperationCancelled = OperationCancelled;
-exports.delayNextTick = delayNextTick;
-exports.interruptAndCheck = interruptAndCheck;
-exports.isOperationCancelled = isOperationCancelled;
-exports.startCancelableOperation = startCancelableOperation;

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/utils/promise-utils.mjs

@@ -1,94 +0,0 @@
-import { c as cancellationExports } from '../../../../../../../_virtual/cancellation.mjs';
-
-/******************************************************************************
- * Copyright 2021 TypeFox GmbH
- * This program and the accompanying materials are made available under the
- * terms of the MIT License, which is available in the project root.
- ******************************************************************************/
-/**
- * Delays the execution of the current code to the next tick of the event loop.
- * Don't call this method directly in a tight loop to prevent too many promises from being created.
- */
-function delayNextTick() {
-    return new Promise(resolve => {
-        // In case we are running in a non-node environment, `setImmediate` isn't available.
-        // Using `setTimeout` of the browser API accomplishes the same result.
-        if (typeof setImmediate === 'undefined') {
-            setTimeout(resolve, 0);
-        }
-        else {
-            setImmediate(resolve);
-        }
-    });
-}
-let lastTick = 0;
-let globalInterruptionPeriod = 10;
-/**
- * Reset the global interruption period and create a cancellation token source.
- */
-function startCancelableOperation() {
-    lastTick = performance.now();
-    return new cancellationExports.CancellationTokenSource();
-}
-/**
- * This symbol may be thrown in an asynchronous context by any Langium service that receives
- * a `CancellationToken`. This means that the promise returned by such a service is rejected with
- * this symbol as rejection reason.
- */
-const OperationCancelled = Symbol('OperationCancelled');
-/**
- * Use this in a `catch` block to check whether the thrown object indicates that the operation
- * has been cancelled.
- */
-function isOperationCancelled(err) {
-    return err === OperationCancelled;
-}
-/**
- * This function does two things:
- *  1. Check the elapsed time since the last call to this function or to `startCancelableOperation`. If the predefined
- *     period (configured with `setInterruptionPeriod`) is exceeded, execution is delayed with `delayNextTick`.
- *  2. If the predefined period is not met yet or execution is resumed after an interruption, the given cancellation
- *     token is checked, and if cancellation is requested, `OperationCanceled` is thrown.
- *
- * All services in Langium that receive a `CancellationToken` may potentially call this function, so the
- * `CancellationToken` must be caught (with an `async` try-catch block or a `catch` callback attached to
- * the promise) to avoid that event being exposed as an error.
- */
-async function interruptAndCheck(token) {
-    if (token === cancellationExports.CancellationToken.None) {
-        // Early exit in case cancellation was disabled by the caller
-        return;
-    }
-    const current = performance.now();
-    if (current - lastTick >= globalInterruptionPeriod) {
-        lastTick = current;
-        await delayNextTick();
-        // prevent calling delayNextTick every iteration of loop
-        // where delayNextTick takes up the majority or all of the
-        // globalInterruptionPeriod itself
-        lastTick = performance.now();
-    }
-    if (token.isCancellationRequested) {
-        throw OperationCancelled;
-    }
-}
-/**
- * Simple implementation of the deferred pattern.
- * An object that exposes a promise and functions to resolve and reject it.
- */
-class Deferred {
-    constructor() {
-        this.promise = new Promise((resolve, reject) => {
-            this.resolve = (arg) => {
-                resolve(arg);
-                return this;
-            };
-            this.reject = (err) => {
-                reject(err);
-                return this;
-            };
-        });
-    }
-}
-
-export { Deferred, OperationCancelled, delayNextTick, interruptAndCheck, isOperationCancelled, startCancelableOperation };