"pages/todo"存在Function问题

原始输入文件：

/**
 * ACE @ Web Helsinki
 *
 * eDSL version of TODO application
 *
 * ( unverified due to lack of working eDSL transpiler )
 *
 * For comparison, the plain JS version of this app that works with ACE-Diff can be found here
 * https://rnd-gitlab-eu-c.huawei.com/zidanehbs/ace/ace/-/blob/fin-hmf-dev-ace-diff-clean/samples/common/res/hi_topapp/assets/js/default/acediff/todoListForEach.js
 * This is the ouput the eDSL transpiler should generate.
 */

let tasks: Array<any> = [
  { label: "Wash the car" },
  { label: "Buy some milk" },
  { label: "Make the report" },
  { label: "Buy flight tickets" },
  { label: "Update profile" },
  { label: "Change tyres" },
  { label: "Walk the dog" },
  { label: "Feed the dog" },
  { label: "Paint the walls" },
  { label: "Wash dishes" },
  { label: "Water flowers" },
  { label: "Call parents" },
  { label: "Refactor: align_component.cpp" },
  { label: "Refactor: align_component.h" },
  { label: "Refactor: arc_component.cpp" },
  { label: "Refactor: arc_component.h" },
  { label: "Refactor: block_component.cpp" },
  { label: "Refactor: block_component.h" },
  { label: "Refactor: box_base_component.cpp" },
  { label: "Refactor: box_base_component.h" },
  { label: "Refactor: box_component.cpp" },
  { label: "Refactor: box_component.h" },
  { label: "Refactor: bubble_component.cpp" },
  { label: "Refactor: bubble_component.h" },
  { label: "Refactor: button_component.cpp" },
  { label: "Refactor: button_component.h" },
  { label: "Refactor: calendar_component.cpp" },
  { label: "Refactor: calendar_component.h" },
  { label: "Refactor: calendar_data_adapter.cpp" },
  { label: "Refactor: calendar_data_adapter.h" },
  { label: "Refactor: chart_component.cpp" },
  { label: "Refactor: chart_component.h" },
  { label: "Refactor: checkable_component.cpp" },
  { label: "Refactor: checkable_component.h" },
  { label: "Refactor: clip_component.cpp" },
  { label: "Refactor: clip_component.h" },
  { label: "Refactor: component.cpp" },
  { label: "Refactor: component_group.h" },
  { label: "Refactor: component.h" },
  { label: "Refactor: composed_component.cpp" },
  { label: "Refactor: composed_component.h" },
  { label: "Refactor: constants.cpp" },
  { label: "Refactor: constants.h" },
  { label: "Refactor: sole_child_component.h" },
  { label: "Refactor: stack_component.h" },
  { label: "Refactor: stage_component.h" },
  { label: "Refactor: swiper_component.h" },
  { label: "Refactor: tab_bar_component.cpp" },
  { label: "Refactor: tab_bar_component.h" },
  { label: "Refactor: tab_bar_indicator_component.cpp" },
  { label: "Refactor: tab_bar_indicator_component.h" },
  { label: "Refactor: tab_bar_item_component.cpp" },
  { label: "Refactor: tab_bar_item_component.h" },
  { label: "Refactor: tab_content_component.cpp" },
  { label: "Refactor: tab_content_component.h" },
  { label: "Refactor: tab_controller.cpp" },
  { label: "Refactor: tab_controller.h" },
  { label: "Refactor: test" },
  { label: "Refactor: text_component.cpp" },
  { label: "Refactor: text_component.h" },
  { label: "Refactor: text_field_component.cpp" },
  { label: "Refactor: text_field_component.h" },
  { label: "Refactor: text_field_controller.cpp" },
  { label: "Refactor: text_field_controller.h" },
  { label: "Refactor: text_overlay_component.cpp" },
  { label: "Refactor: text_overlay_component.h" },
  { label: "Refactor: text_span_component.cpp" },
  { label: "Refactor: text_span_component.h" },
  { label: "Refactor: texture_component.cpp" },
  { label: "Refactor: texture_component.h" },
  { label: "Refactor: toast_component.cpp" },
  { label: "Refactor: toast_component.h" },
  { label: "Refactor: toggle_component.cpp" },
  { label: "Refactor: toggle_component.h" },
  { label: "Refactor: touch_listener_component.h" },
  { label: "Refactor: track_component.cpp" },
  { label: "Refactor: track_component.h" },
  { label: "Refactor: transform_component.cpp" },
  { label: "Refactor: transform_component.h" },
  { label: "Refactor: transition_component.cpp" },
  { label: "Refactor: transition_component.h" },
  { label: "Refactor: triangle_component.cpp" },
  { label: "Refactor: triangle_component.h" },
  { label: "Refactor: tween_component.cpp" },
  { label: "Refactor: tween_component.h" },
  { label: "Refactor: video_component.cpp" },
  { label: "Refactor: video_component.h" },
  { label: "Refactor: watch_slider_component.cpp" },
  { label: "Refactor: watch_slider_component.h" },
  { label: "Refactor: wrap_component.h" },
  { /* not used */ }
]

// Add ID for each task
tasks.forEach(function (item, index) {
  item.id = index
  tasks[index] = item
})

let tasksCount: number = tasks.length - 1
let screenCount: number = 20

@Entry
@Component
struct RootView {
  @State idx: number = 0

build() {
    Column () {
      Column() {
        Row() {
          Button("Next task")
            .onClick(() => {
              if (this.idx < tasksCount - screenCount)
                this.idx++
            })
          Button("Prev task")
            .onClick(() => {
              if (this.idx > 0)
                this.idx--
            })
        }
      }
      ForEach(
          /* first parameter is an expression of type array.
            the point of not just using an array here is to clarify ForEach can not just perate on the
            source array (as repeat implementation in ACE-Light did) */
          tasks.slice(this.idx, this.idx + screenCount),

/* the third, builder function take an item as input and creates a single View from it */
          item => {
            Text((item.id + 1) + " : " + item.label)
          },

/* second parameter is a arrow function that takes an item as input
          and returns a persistent nique id (or key ) */
          item => item.id
      ) // ForEach
      Text("--- Page navigation ---")
      Row() {
        Button("First")
        .onClick(() => this.idx = 0)
        Button("End")
          .onClick(() => this.idx = tasksCount - screenCount)
      }
    }
  } // build
}  // struct

转换后的js文件：

问题现象：
节点undefined
![输入图片说明](https://images.gitee.com/uploads/images/2021/0928/112015_746e9a2e_9580268.png "屏幕截图.png")

代码：
对function进行判断
js：
![输入图片说明](https://images.gitee.com/uploads/images/2021/0928/111100_a8f055fa_9580268.png "屏幕截图.png")
ts:
![输入图片说明](https://images.gitee.com/uploads/images/2021/0928/112050_f4037b24_9580268.png "屏幕截图.png"))

原因：
parameter应该为空，但是有值
![输入图片说明](https://images.gitee.com/uploads/images/2021/0928/111233_9791d1f4_9580268.png "屏幕截图.png")

建议：
对于该节点判断屏蔽

![输入图片说明](https://images.gitee.com/uploads/images/2021/0928/150321_c7c70ee5_9580268.png "屏幕截图.png")

![输入图片说明](https://images.gitee.com/uploads/images/2021/0928/185007_6c3917b0_9580268.png "屏幕截图.png")

ETS:ERROR File: /mnt/e/repo/openharmony/developtools/ace-ets2bundle/compiler/setting/pages/settingList.ets:23:36
 TS2307: Cannot find module '../model/brightnessImpl/BrightnessSettingModel.ets' or its corresponding type declarations.

/**
 * Copyright (c) 2021 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import LogUtil from '../common/baseUtil/LogUtil.ets';
import ConfigData from '../common/baseUtil/ConfigData.ets';
import EntryComponent from './component/entryComponent.ets';
import HeadComponent from './component/headComponent.ets';
import SettingListModel from '../model/settingListImpl/SettingListModel.ets';
import WifiModel from '../model/wifiImpl/WifiModel.ets';
import SubscriberUtils from '../common/baseUtil/SubscriberUtil.ets';
import GlobalResourceManager from '../common/baseUtil/GlobalResourceManager.ets';
import BrightnessSettingModel from '../model/brightnessImpl/BrightnessSettingModel.ets';
var Router = globalThis.requireNativeModule('system.router');
const SETTING_LIST_INDEX = 0;
class SettingList extends View {
    constructor(compilerAssignedUniqueChildId, parent, params) {
        super(compilerAssignedUniqueChildId, parent);
        this.__settingsList = new ObservedPropertyObject([], this, "settingsList");
        this.__wifiStatus = new ObservedPropertySimple(false, this, "wifiStatus");
        this.__status = new ObservedPropertyObject('', this, "status");
        this.updateWithValueParams(params);
    }
    updateWithValueParams(params) {
        if (params.settingsList !== undefined) {
            this.settingsList = params.settingsList;
        }
        if (params.wifiStatus !== undefined) {
            this.wifiStatus = params.wifiStatus;
        }
        if (params.status !== undefined) {
            this.status = params.status;
        }
    }
    aboutToBeDeleted() {
        this.__settingsList.aboutToBeDeleted();
        this.__wifiStatus.aboutToBeDeleted();
        this.__status.aboutToBeDeleted();
        SubscriberManager.Get().delete(this.id());
    }
    get settingsList() {
        return this.__settingsList.get();
    }
    set settingsList(newValue) {
        this.__settingsList.set(newValue);
    }
    get wifiStatus() {
        return this.__wifiStatus.get();
    }
    set wifiStatus(newValue) {
        this.__wifiStatus.set(newValue);
    }
    get status() {
        return this.__status.get();
    }
    set status(newValue) {
        this.__status.set(newValue);
    }
    render() {
        Column.create();
        Column.width(ConfigData.WH_100_100);
        Column.height(ConfigData.WH_100_100);
        let earlierCreatedChild_2 = this.findChildById("2");
        if (earlierCreatedChild_2 == undefined) {
            View.create(new HeadComponent("2", this, { icBackIsVisibility: false, headName: $r('app.string.settings'), isActive: false }));
        }
        else {
            earlierCreatedChild_2.updateWithValueParams({
                icBackIsVisibility: false, headName: $r('app.string.settings'), isActive: false
            });
            View.create(earlierCreatedChild_2);
        }
        List.create();
        List.divider({
            strokeWidth: 1,
            color: $r('app.color.color_E3E3E3_grey'),
            startMargin: $r('app.float.wh_value_65'),
            endMargin: $r('app.float.wh_value_15')
        });
        List.width(ConfigData.WH_100_100);
        List.height(ConfigData.WH_100_100);
        List.alignSelf(ItemAlign.Start);
        ForEach.create("4", this, ObservedObject.GetRawObject(this.settingsList), (item) => {
            ListItem.create();
            ListItem.onTouch(() => {
                Router.push({
                    uri: item.settingUri,
                });
            });
            ListItem.height($r('app.float.wh_value_70'));
            Navigator.create({ target: item.settingUri });
            let earlierCreatedChild_3 = this.findChildById("3");
            if (earlierCreatedChild_3 == undefined) {
                View.create(new EntryComponent("3", this, {
                    settingIcon: item.settingIcon,
                    settingTitle: item.settingTitle,
                    settingSummary: item.settingSummary,
                    settingValue: item.settingValue,
                    settingArrow: item.settingArrow,
                    settingArrowStyle: '',
                    settingUri: item.settingUri
                }));
            }
            else {
                earlierCreatedChild_3.updateWithValueParams({
                    settingIcon: item.settingIcon,
                    settingTitle: item.settingTitle,
                    settingSummary: item.settingSummary,
                    settingValue: item.settingValue,
                    settingArrow: item.settingArrow,
                    settingArrowStyle: '',
                    settingUri: item.settingUri
                });
                View.create(earlierCreatedChild_3);
            }
            Navigator.pop();
            ListItem.pop();
        });
        ForEach.pop();
        List.pop();
        Column.pop();
    }
    aboutToAppear() {
        LogUtil.info('settings SettingList aboutToAppear enter');
        this.settingsList = SettingListModel.setSettingListener();
        SubscriberUtils.registerStatusListener();
        LogUtil.info('settings SettingList aboutToAppear startPage');
        SettingListModel.startPage(this.pageValue);
        this.setTitleValue();
        let nYear = GlobalResourceManager.getStringByResource($r('app.string.year'));
        nYear.then(resp => BrightnessSettingModel.setStorageValue(ConfigData.DATE_AND_TIME_YEAR, resp));
        let nMonth = GlobalResourceManager.getStringByResource($r('app.string.month'));
        nMonth.then(resp => BrightnessSettingModel.setStorageValue(ConfigData.DATE_AND_TIME_MONTH, resp));
        let nDay = GlobalResourceManager.getStringByResource($r('app.string.day'));
        nDay.then(resp => {
            BrightnessSettingModel.setStorageValue(ConfigData.DATE_AND_TIME_DAY, resp);
            LogUtil.info('SettingList day:' + BrightnessSettingModel.getStorageValue(ConfigData.DATE_AND_TIME_DAY, ''));
        });
        LogUtil.info('settings SettingList aboutToAppear end');
    }
    pageValue(pagePath) {
        LogUtil.info('settings settingList pageValue pagePath:' + pagePath);
        if ('pages/wifi' === pagePath) {
            Router.push({
                uri: 'pages/wifi',
            });
        }
        LogUtil.info('settings settingList pageValue end');
    }
    setTitleValue() {
        LogUtil.info('SettingList setTitleValue this.settingsList:' + JSON.stringify(this.settingsList));
        for (let key in this.settingsList) {
            let settingAlias = this.settingsList[key].settingAlias;
            let value;
            this.wifiStatus = WifiModel.getWifiStatus();
            if ('wifiTab' === settingAlias) {
                value = $r('app.string.wifiTab');
                if (this.wifiStatus) {
                    this.settingsList[key].settingValue = $r('app.string.enabled');
                }
                else {
                    this.settingsList[key].settingValue = $r('app.string.disabled');
                }
            }
            else if ('brightnessTab' === settingAlias) {
                value = $r('app.string.brightnessTab');
            }
            else if ('applyTab' === settingAlias) {
                value = $r('app.string.applyTab');
            }
            else if ('dateAndTimeTab' === settingAlias) {
                value = $r('app.string.dateAndTimeTab');
            }
            else if ('aboutTab' === settingAlias) {
                value = $r('app.string.aboutTab');
            }
            this.settingsList[key].settingTitle = value;
        }
        LogUtil.info('SettingList setTitleValue this.settingsList:' + JSON.stringify(this.settingsList));
    }
    onPageShow() {
        LogUtil.info('SettingList onPageShow in:' + JSON.stringify(this.settingsList));
        this.wifiStatus = WifiModel.getWifiStatus();
        LogUtil.info('SettingList onPageShow this.wifiStatus:' + this.wifiStatus);
        for (let key in this.settingsList) {
            let settingAlias = this.settingsList[key].settingAlias;
            if ('wifiTab' === settingAlias) {
                if (this.wifiStatus) {
                    this.status = $r('app.string.enabled');
                }
                else {
                    this.status = $r('app.string.disabled');
                }
                LogUtil.info('SettingList onPageShow settingValue:' + this.settingsList[key].settingValue);
            }
        }
        this.settingsList.unshift({
            settingSummary: '',
            settingTitle: this.settingsList[SETTING_LIST_INDEX].settingTitle,
            settingValue: this.status,
            settingAlias: this.settingsList[SETTING_LIST_INDEX].settingAlias,
            settingIcon: this.settingsList[SETTING_LIST_INDEX].settingIcon,
            settingArrow: this.settingsList[SETTING_LIST_INDEX].settingArrow,
            settingUri: this.settingsList[SETTING_LIST_INDEX].settingUri,
        });
        this.settingsList.splice(1, 1);
        LogUtil.info('SettingList onPageShow out:' + +JSON.stringify(this.settingsList));
    }
    aboutToDisappear() {
        LogUtil.info('settingList aboutToDisappear in');
        SubscriberUtils.unSubscriberListener();
        LogUtil.info('settingList aboutToDisappear out');
    }
}
loadDocument(new SettingList("1", undefined, {}));

// normal
function foo1(a, b) {
    return a+b;
}

foo1(1,2);
foo1(1);
foo1(1,2,3,4)

// arguments
function foo2() {
    return arguments[0];
}

foo2(1);

// restargs
function foo3(...a) {
    return a[0]
}

foo3(1,2,3)

.language ECMAScript

.function any foo1(any a0, any a1, any a2, any a3, any a4) {
        mov.dyn v4, a4
        mov.dyn v3, a3
        mov.dyn v2, a2
        mov.dyn v1, a1
        mov.dyn v0, a0
        ecma.ldlexenvdyn
        sta.dyn v7
        lda.dyn v3
        sta.dyn v6
        lda.dyn v4
        ecma.add2dyn v6
        sta.dyn v5
        lda.dyn v5
        return.dyn
}

.function any foo2(any a0, any a1, any a2) {
        mov.dyn v2, a2
        mov.dyn v1, a1
        mov.dyn v0, a0
        ecma.ldlexenvdyn
        sta.dyn v7
        ecma.getunmappedargs
        sta.dyn v3
        lda.dyn v3
        sta.dyn v5
        ecma.ldobjbyindex v5, 0
        sta.dyn v4
        lda.dyn v4
        return.dyn
}

.function any foo3(any a0, any a1, any a2, any a3) {
        mov.dyn v3, a3
        mov.dyn v2, a2
        mov.dyn v1, a1
        mov.dyn v0, a0
        ecma.ldlexenvdyn
        sta.dyn v7
        ecma.copyrestargs 0
        sta.dyn v3
        lda.dyn v3
        sta.dyn v5
        ecma.ldobjbyindex v5, 0
        sta.dyn v4
        lda.dyn v4
        return.dyn
}

.function any func_main_0(any a0, any a1, any a2) {
        mov.dyn v2, a2
        mov.dyn v1, a1
        mov.dyn v0, a0
        ecma.ldlexenvdyn
        sta.dyn v8
        ecma.definefuncdyn foo1, 2, v8
        ecma.stglobalvar "foo1"
        ecma.definefuncdyn foo2, 0, v8
        ecma.stglobalvar "foo2"
        ecma.definefuncdyn foo3, 0, v8
        ecma.stglobalvar "foo3"
        ecma.ldglobalvar "foo1"
        sta.dyn v3
        ldai.dyn 1
        sta.dyn v4
        ldai.dyn 2
        sta.dyn v5
        ecma.callargs2dyn v3, v4, v5
        ecma.ldglobalvar "foo1"
        sta.dyn v3
        ldai.dyn 1
        sta.dyn v4
        ecma.callarg1dyn v3, v4
        ecma.ldglobalvar "foo1"
        sta.dyn v3
        ldai.dyn 1
        sta.dyn v4
        ldai.dyn 2
        sta.dyn v5
        ldai.dyn 3
        sta.dyn v6
        ldai.dyn 4
        sta.dyn v7
        ecma.callirangedyn 4, v3
        ecma.ldglobalvar "foo2"
        sta.dyn v3
        ldai.dyn 1
        sta.dyn v4
        ecma.callarg1dyn v3, v4
        ecma.ldglobalvar "foo3"
        sta.dyn v3
        ldai.dyn 1
        sta.dyn v4
        ldai.dyn 2
        sta.dyn v5
        ldai.dyn 3
        sta.dyn v6
        ecma.callargs3dyn v3, v4, v5, v6
        ecma.returnundefined
}

.language ECMAScript

.function any Base(any a0, any a1, any a2) {
        mov.dyn v2, a2
        mov.dyn v1, a1
        mov.dyn v0, a0
        ecma.ldlexenvdyn
        sta.dyn v3
        ecma.returnundefined
}

.function any #2#m(any a0, any a1, any a2, any a3) {
        mov.dyn v3, a3
        mov.dyn v2, a2
        mov.dyn v1, a1
        mov.dyn v0, a0
        ecma.ldlexenvdyn
        sta.dyn v6
        ecma.tryldglobalbyname "print"
        sta.dyn v4
        lda.str "`Base.prototype.m` is unreachable."
        sta.dyn v5
        ecma.callarg1dyn v4, v5
        ecma.returnundefined
}

.function any #3#C(any a0, any a1, any a2, any a3) {
        mov.dyn v3, a3
        mov.dyn v2, a2
        mov.dyn v1, a1
        mov.dyn v0, a0
        ecma.ldlexenvdyn
        sta.dyn v6
        ecma.copyrestargs 0
        sta.dyn v3
        ecma.createemptyarray
        sta.dyn v4
        ldai.dyn 0
        sta.dyn v5
        lda.dyn v3
        ecma.starrayspread v4, v5
        sta.dyn v5
        lda.dyn v4
        lda.dyn v0
        ecma.supercallspread v4
        sta.dyn v4
        mov.dyn v5, v2
        lda.dyn v5
        ecma.throwifsupernotcorrectcall 1
        lda.dyn v4
        sta.dyn v2
        mov.dyn v4, v2
        lda.dyn v4
        mov.dyn v5, v2
        lda.dyn v5
        ecma.throwifsupernotcorrectcall 0
        return.dyn
}

.function any #4#m(any a0, any a1, any a2) {
        mov.dyn v2, a2
        mov.dyn v1, a1
        mov.dyn v0, a0
        ecma.ldlexenvdyn
        sta.dyn v4
        ldai.dyn 1
        sta.dyn v3
        lda.dyn v3
        return.dyn
}

.function any func_main_0(any a0, any a1, any a2) {
        mov.dyn v2, a2
        mov.dyn v1, a1
        mov.dyn v0, a0
        ecma.ldfalse
        sta.dyn v13
        ecma.ldlexenvdyn
        sta.dyn v12
        ecma.ldundefined
        sta.dyn v11
        ecma.definefuncdyn Base, 0, v12
        sta.dyn v3
        lda.str "use strict"
        lda.dyn v3
        sta.dyn v6
        mov.dyn v4, v6
        ecma.createobjectwithbuffer 0
        sta.dyn v6
        lda.dyn v6
        ecma.definemethod #2#m, 1, v12
        sta.dyn v8
        lda.str "m"
        sta.dyn v9
        lda.dyn v13
        ecma.definegettersetterbyvalue v6, v9, v11, v8
        lda.dyn v6
        ecma.stobjbyname "prototype", v4
        lda.dyn v3
        sta.dyn v5
        ecma.defineclasswithbuffer #3#C, 1, 0, v12, v5
        sta.dyn v4
        lda.dyn v4
        ecma.stclasstoglobalrecord "C"
        ecma.tryldglobalbyname "print"
        sta.dyn v4
        ecma.tryldglobalbyname "C"
        sta.dyn v9
        mov.dyn v10, v9
        ecma.newobjdynrange 2, v9
        sta.dyn v7
        ecma.ldobjbyname "m", v7
        sta.dyn v6
        ecma.callithisrangedyn 1, v6
        sta.dyn v5
        ecma.callarg1dyn v4, v5
        ecma.returnundefined
}

/*
  * Copyright (c) 2021 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

declare type CanvasFillRule = 'evenodd' | 'nonzero';
declare type CanvasLineCap = 'butt' | 'round' | 'square';
declare type CanvasLineJoin = 'bevel' | 'miter' | 'round';
declare type CanvasDirection = 'inherit' | 'ltr' | 'rtl';
declare type CanvasTextAlign = 'center' | 'end' | 'left' | 'right' | 'start';
declare type CanvasTextBaseline = 'alphabetic' | 'bottom' | 'hanging' | 'ideographic' | 'middle' | 'top';
declare type ImageSmoothingQuality = 'high' | 'low' | 'medium';
declare class CanvasGradient {
    addColorStop(offset: number, color: string): void;
}
declare class CanvasPath {
    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
    closePath(): void;
    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: number): void;
    lineTo(x: number, y: number): void;
    moveTo(x: number, y: number): void;
    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
    rect(x: number, y: number, w: number, h: number): void;
}
declare class Path2D extends CanvasPath {
    addPath(path: Path2D, transform?: Matrix2D): void;
    constructor();
    constructor(path: Path2D);
    constructor(d: string);
}
declare interface CanvasPattern {
    setTransform(transform?: Matrix2D): void;
}
declare interface TextMetrics {
    readonly actualBoundingBoxAscent: number;
    readonly actualBoundingBoxDescent: number;
    readonly actualBoundingBoxLeft: number;
    readonly actualBoundingBoxRight: number;
    readonly alphabeticBaseline: number;
    readonly emHeightAscent: number;
    readonly emHeightDescent: number;
    readonly fontBoundingBoxAscent: number;
    readonly fontBoundingBoxDescent: number;
    readonly hangingBaseline: number;
    readonly ideographicBaseline: number;
    readonly width: number;
}
declare class ImageBitmap {
    readonly height: number;
    readonly width: number;
    close(): void;
    constructor(src: string);
    constructor(data: PixelMap);
}
declare interface ImageData {
    readonly data: Uint8ClampedArray;
    readonly height: number;
    readonly width: number;
    constructor(width: number, height: number, data?: Uint8ClampedArray);
}
declare class RenderingContextSettings {
    alpha?: boolean;
    antialias?: boolean;
    constructor(antialias?: boolean, alpha?: boolean);
}
declare class CanvasRenderer extends CanvasPath {
    globalAlpha: number;
    globalCompositeOperation: string;
    drawImage(image: ImageBitmap, dx: number, dy: number): void;
    drawImage(image: ImageBitmap, dx: number, dy: number, dw: number, dh: number): void;
    drawImage(image: ImageBitmap, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
    beginPath(): void;
    clip(fillRule?: CanvasFillRule): void;
    clip(path: Path2D, fillRule?: CanvasFillRule): void;
    fill(fillRule?: CanvasFillRule): void;
    fill(path: Path2D, fillRule?: CanvasFillRule): void;
    stroke(): void;
    stroke(path: Path2D): void;
    fillStyle: string | CanvasGradient | CanvasPattern;
    strokeStyle: string | CanvasGradient | CanvasPattern;
    createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
    createPattern(image: ImageBitmap, repetition: string | null): CanvasPattern | null;
    createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
    filter(filter: string): void;
    createImageData(sw: number, sh: number): ImageData;
    createImageData(imagedata: ImageData): ImageData;
    getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
    putImageData(imagedata: ImageData, dx: number, dy: number): void;
    putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): void;
    imageSmoothingEnabled: boolean;
    imageSmoothingQuality(quality: ImageSmoothingQuality): void;
    lineCap: CanvasLineCap;
    lineDashOffset: number;
    lineJoin: CanvasLineJoin;
    lineWidth: number;
    miterLimit: number;
    getLineDash(): number[];
    setLineDash(segments: number[]): void;
    clearRect(x: number, y: number, w: number, h: number): void;
    fillRect(x: number, y: number, w: number, h: number): void;
    strokeRect(x: number, y: number, w: number, h: number): void;
    shadowBlur: number;
    shadowColor: string;
    shadowOffsetX: number;
    shadowOffsetY: number;
    restore(): void;
    save(): void;
    fillText(text: string, x: number, y: number, maxWidth?: number): void;
    measureText(text: string): TextMetrics;
    strokeText(text: string, x: number, y: number, maxWidth?: number): void;
    direction(direction: CanvasDirection): void;
    font: string;
    textAlign: CanvasTextAlign;
    textBaseline: CanvasTextBaseline;
    getTransform(): Matrix2D;
    resetTransform(): void;
    rotate(angle: number): void;
    scale(x: number, y: number): void;
    setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
    setTransform(transform?: Matrix2D): void;
    transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
    translate(x: number, y: number): void;
    setPixelMap(value?: PixelMap): void;
    transferFromImageBitmap(bitmap: ImageBitmap): void;
}
declare class CanvasRenderingContext2D extends CanvasRenderer {
    readonly height: number;
    readonly width: number;
    toDataURL(type?: string, quality?: any): string;
    constructor(settings?: RenderingContextSettings);
}
declare class OffscreenCanvasRenderingContext2D extends CanvasRenderer {
    toDataURL(type?: string, quality?: any): string;
    transferToImageBitmap(): ImageBitmap;
    constructor(width: number, height: number, settings?: RenderingContextSettings);
}
declare interface OffscreenCanvas extends CanvasRenderer {
    height: number;
    width: number;
    transferToImageBitmap(): ImageBitmap;
    constructor(width: number, height: number);
}
interface Canvas extends CanvasAttribute<Canvas> {
    (context?: CanvasRenderingContext2D): Canvas;
}
declare class CanvasAttribute<T> extends CommonMethod<T> {
    onReady(event: () => void): T;
}
declare class CanvasExtend<T> extends CanvasAttribute<T> {
}
declare const Canvas: Canvas;

zrg/developtools_ace-ets2bundle

内容风险标识

评论 (45)

zrg/developtools_ace-ets2bundle .gitee-modal { width: 500px !important; }

内容风险标识