@mcp-b/chrome-devtools-mcp 1.1.0 → 1.1.1

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/AutofillModel.js

@@ -0,0 +1,155 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Common from '../../core/common/common.js';
+import * as Host from '../host/host.js';
+import { SDKModel } from './SDKModel.js';
+export class AutofillModel extends SDKModel {
+    agent;
+    #enabled;
+    #showTestAddressesInAutofillMenu;
+    constructor(target) {
+        super(target);
+        this.agent = target.autofillAgent();
+        this.#showTestAddressesInAutofillMenu =
+            Common.Settings.Settings.instance().createSetting('show-test-addresses-in-autofill-menu-on-event', false);
+        this.#showTestAddressesInAutofillMenu.addChangeListener(this.#setTestAddresses, this);
+        target.registerAutofillDispatcher(this);
+        this.enable();
+    }
+    dispose() {
+        this.#showTestAddressesInAutofillMenu.removeChangeListener(this.#setTestAddresses, this);
+        super.dispose();
+    }
+    #setTestAddresses() {
+        void this.agent.invoke_setAddresses({
+            addresses: this.#showTestAddressesInAutofillMenu.get() ?
+                [
+                    {
+                        fields: [
+                            { name: 'ADDRESS_HOME_COUNTRY', value: 'US' },
+                            { name: 'NAME_FULL', value: 'Jon Stewart Doe' },
+                            { name: 'NAME_FIRST', value: 'Jon' },
+                            { name: 'NAME_MIDDLE', value: 'Stewart' },
+                            { name: 'NAME_LAST', value: 'Doe' },
+                            { name: 'COMPANY_NAME', value: 'Fake Company' },
+                            { name: 'ADDRESS_HOME_LINE1', value: '1600 Fake Street' },
+                            { name: 'ADDRESS_HOME_LINE2', value: 'Apartment 1' },
+                            { name: 'ADDRESS_HOME_ZIP', value: '94043' },
+                            { name: 'ADDRESS_HOME_CITY', value: 'Mountain View' },
+                            { name: 'ADDRESS_HOME_STATE', value: 'CA' },
+                            { name: 'EMAIL_ADDRESS', value: 'test@example.us' },
+                            { name: 'PHONE_HOME_WHOLE_NUMBER', value: '+16019521325' },
+                        ],
+                    },
+                    {
+                        fields: [
+                            { name: 'ADDRESS_HOME_COUNTRY', value: 'BR' },
+                            { name: 'NAME_FULL', value: 'João Souza Silva' },
+                            { name: 'NAME_FIRST', value: 'João' },
+                            { name: 'NAME_LAST', value: 'Souza Silva' },
+                            { name: 'NAME_LAST_FIRST', value: 'Souza' },
+                            { name: 'NAME_LAST_SECOND', value: 'Silva' },
+                            { name: 'COMPANY_NAME', value: 'Empresa Falsa' },
+                            { name: 'ADDRESS_HOME_STREET_ADDRESS', value: 'Rua Inexistente, 2000\nAndar 2, Apartamento 1' },
+                            { name: 'ADDRESS_HOME_STREET_LOCATION', value: 'Rua Inexistente, 2000' },
+                            { name: 'ADDRESS_HOME_STREET_NAME', value: 'Rua Inexistente' },
+                            { name: 'ADDRESS_HOME_HOUSE_NUMBER', value: '2000' },
+                            { name: 'ADDRESS_HOME_SUBPREMISE', value: 'Andar 2, Apartamento 1' },
+                            { name: 'ADDRESS_HOME_APT_NUM', value: '1' },
+                            { name: 'ADDRESS_HOME_FLOOR', value: '2' },
+                            { name: 'ADDRESS_HOME_APT', value: 'Apartamento 1' },
+                            { name: 'ADDRESS_HOME_APT_TYPE', value: 'Apartamento' },
+                            { name: 'ADDRESS_HOME_APT_NUM', value: '1' },
+                            { name: 'ADDRESS_HOME_DEPENDENT_LOCALITY', value: 'Santa Efigênia' },
+                            { name: 'ADDRESS_HOME_LANDMARK', value: 'Próximo à estação Santa Efigênia' },
+                            { name: 'ADDRESS_HOME_OVERFLOW', value: 'Andar 2, Apartamento 1' },
+                            { name: 'ADDRESS_HOME_ZIP', value: '30260-080' },
+                            { name: 'ADDRESS_HOME_CITY', value: 'Belo Horizonte' },
+                            { name: 'ADDRESS_HOME_STATE', value: 'MG' },
+                            { name: 'EMAIL_ADDRESS', value: 'teste@exemplo.us' },
+                            { name: 'PHONE_HOME_WHOLE_NUMBER', value: '+553121286800' },
+                        ],
+                    },
+                    {
+                        fields: [
+                            { name: 'ADDRESS_HOME_COUNTRY', value: 'MX' },
+                            { name: 'NAME_FULL', value: 'Juan Francisco García Flores' },
+                            { name: 'NAME_FIRST', value: 'Juan Francisco' },
+                            { name: 'NAME_LAST', value: 'García Flores' },
+                            { name: 'NAME_LAST_FIRST', value: 'García' },
+                            { name: 'NAME_LAST_SECOND', value: 'Flores' },
+                            { name: 'COMPANY_NAME', value: 'Empresa Falsa' },
+                            {
+                                name: 'ADDRESS_HOME_STREET_ADDRESS',
+                                value: 'C. Falsa 445\nPiso 2, Apartamento 1\nEntre calle Volcán y calle Montes Blancos, cerca de la estación de metro',
+                            },
+                            { name: 'ADDRESS_HOME_STREET_LOCATION', value: 'C. Falsa 445' },
+                            { name: 'ADDRESS_HOME_STREET_NAME', value: 'C. Falsa' },
+                            { name: 'ADDRESS_HOME_HOUSE_NUMBER', value: '445' },
+                            { name: 'ADDRESS_HOME_SUBPREMISE', value: 'Piso 2, Apartamento 1' },
+                            { name: 'ADDRESS_HOME_FLOOR', value: '2' },
+                            { name: 'ADDRESS_HOME_APT', value: 'Apartamento 1' },
+                            { name: 'ADDRESS_HOME_APT_TYPE', value: 'Apartamento' },
+                            { name: 'ADDRESS_HOME_APT_NUM', value: '1' },
+                            { name: 'ADDRESS_HOME_DEPENDENT_LOCALITY', value: 'Lomas de Chapultepec' },
+                            {
+                                name: 'ADDRESS_HOME_OVERFLOW',
+                                value: 'Entre calle Volcán y calle Montes Celestes, cerca de la estación de metro',
+                            },
+                            {
+                                name: 'ADDRESS_HOME_BETWEEN_STREETS_OR_LANDMARK',
+                                value: 'Entre calle Volcán y calle Montes Blancos, cerca de la estación de metro',
+                            },
+                            { name: 'ADDRESS_HOME_LANDMARK', value: 'Cerca de la estación de metro' },
+                            { name: 'ADDRESS_HOME_BETWEEN_STREETS', value: 'Entre calle Volcán y calle Montes Blancos' },
+                            { name: 'ADDRESS_HOME_BETWEEN_STREETS_1', value: 'calle Volcán' },
+                            { name: 'ADDRESS_HOME_BETWEEN_STREETS_2', value: 'calle Montes Blancos' },
+                            { name: 'ADDRESS_HOME_ADMIN_LEVEL2', value: 'Miguel Hidalgo' },
+                            { name: 'ADDRESS_HOME_ZIP', value: '11001' },
+                            { name: 'ADDRESS_HOME_CITY', value: 'Ciudad de México' },
+                            { name: 'ADDRESS_HOME_STATE', value: 'Distrito Federal' },
+                            { name: 'EMAIL_ADDRESS', value: 'ejemplo@ejemplo.mx' },
+                            { name: 'PHONE_HOME_WHOLE_NUMBER', value: '+525553428400' },
+                        ],
+                    },
+                    {
+                        fields: [
+                            { name: 'ADDRESS_HOME_COUNTRY', value: 'DE' },
+                            { name: 'NAME_FULL', value: 'Gottfried Wilhelm Leibniz' },
+                            { name: 'NAME_FIRST', value: 'Gottfried' },
+                            { name: 'NAME_MIDDLE', value: 'Wilhelm' },
+                            { name: 'NAME_LAST', value: 'Leibniz' },
+                            { name: 'COMPANY_NAME', value: 'Erfundenes Unternehmen' },
+                            { name: 'ADDRESS_HOME_LINE1', value: 'Erfundene Straße 33' },
+                            { name: 'ADDRESS_HOME_LINE2', value: 'Wohnung 1' },
+                            { name: 'ADDRESS_HOME_ZIP', value: '80732' },
+                            { name: 'ADDRESS_HOME_CITY', value: 'München' },
+                            { name: 'EMAIL_ADDRESS', value: 'test@beispiel.de' },
+                            { name: 'PHONE_HOME_WHOLE_NUMBER', value: '+4930303986300' },
+                        ],
+                    },
+                ] :
+                [],
+        });
+    }
+    enable() {
+        if (this.#enabled || Host.InspectorFrontendHost.isUnderTest()) {
+            return;
+        }
+        void this.agent.invoke_enable();
+        this.#setTestAddresses();
+        this.#enabled = true;
+    }
+    disable() {
+        if (!this.#enabled || Host.InspectorFrontendHost.isUnderTest()) {
+            return;
+        }
+        this.#enabled = false;
+        void this.agent.invoke_disable();
+    }
+    addressFormFilled(addressFormFilledEvent) {
+        this.dispatchEventToListeners("AddressFormFilled" /* Events.ADDRESS_FORM_FILLED */, { autofillModel: this, event: addressFormFilledEvent });
+    }
+}
+SDKModel.register(AutofillModel, { capabilities: 2 /* Capability.DOM */, autostart: true });

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CPUProfilerModel.js

@@ -0,0 +1,99 @@
+// Copyright 2014 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as i18n from '../i18n/i18n.js';
+import { DebuggerModel, Location } from './DebuggerModel.js';
+import { SDKModel } from './SDKModel.js';
+const UIStrings = {
+    /**
+     * @description Name of a profile. Placeholder is either a user-supplied name or a number automatically assigned to the profile.
+     * @example {2} PH1
+     */
+    profileD: 'Profile {PH1}',
+};
+const str_ = i18n.i18n.registerUIStrings('core/sdk/CPUProfilerModel.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class CPUProfilerModel extends SDKModel {
+    #nextAnonymousConsoleProfileNumber;
+    #anonymousConsoleProfileIdToTitle;
+    #profilerAgent;
+    #preciseCoverageDeltaUpdateCallback;
+    #debuggerModel;
+    registeredConsoleProfileMessages = [];
+    constructor(target) {
+        super(target);
+        this.#nextAnonymousConsoleProfileNumber = 1;
+        this.#anonymousConsoleProfileIdToTitle = new Map();
+        this.#profilerAgent = target.profilerAgent();
+        this.#preciseCoverageDeltaUpdateCallback = null;
+        target.registerProfilerDispatcher(this);
+        void this.#profilerAgent.invoke_enable();
+        this.#debuggerModel = target.model(DebuggerModel);
+    }
+    runtimeModel() {
+        return this.#debuggerModel.runtimeModel();
+    }
+    debuggerModel() {
+        return this.#debuggerModel;
+    }
+    consoleProfileStarted({ id, location, title }) {
+        if (!title) {
+            title = i18nString(UIStrings.profileD, { PH1: this.#nextAnonymousConsoleProfileNumber++ });
+            this.#anonymousConsoleProfileIdToTitle.set(id, title);
+        }
+        const eventData = this.createEventDataFrom(id, location, title);
+        this.dispatchEventToListeners("ConsoleProfileStarted" /* Events.CONSOLE_PROFILE_STARTED */, eventData);
+    }
+    consoleProfileFinished({ id, location, profile, title }) {
+        if (!title) {
+            title = this.#anonymousConsoleProfileIdToTitle.get(id);
+            this.#anonymousConsoleProfileIdToTitle.delete(id);
+        }
+        const eventData = {
+            ...this.createEventDataFrom(id, location, title),
+            cpuProfile: profile,
+        };
+        this.registeredConsoleProfileMessages.push(eventData);
+        this.dispatchEventToListeners("ConsoleProfileFinished" /* Events.CONSOLE_PROFILE_FINISHED */, eventData);
+    }
+    createEventDataFrom(id, scriptLocation, title) {
+        const debuggerLocation = Location.fromPayload(this.#debuggerModel, scriptLocation);
+        const globalId = this.target().id() + '.' + id;
+        return {
+            id: globalId,
+            scriptLocation: debuggerLocation,
+            title: title || '',
+            cpuProfilerModel: this,
+        };
+    }
+    startRecording() {
+        const intervalUs = 100;
+        void this.#profilerAgent.invoke_setSamplingInterval({ interval: intervalUs });
+        return this.#profilerAgent.invoke_start();
+    }
+    stopRecording() {
+        return this.#profilerAgent.invoke_stop().then(response => response.profile || null);
+    }
+    startPreciseCoverage(jsCoveragePerBlock, preciseCoverageDeltaUpdateCallback) {
+        const callCount = false;
+        this.#preciseCoverageDeltaUpdateCallback = preciseCoverageDeltaUpdateCallback;
+        const allowUpdatesTriggeredByBackend = true;
+        return this.#profilerAgent.invoke_startPreciseCoverage({ callCount, detailed: jsCoveragePerBlock, allowTriggeredUpdates: allowUpdatesTriggeredByBackend });
+    }
+    async takePreciseCoverage() {
+        const r = await this.#profilerAgent.invoke_takePreciseCoverage();
+        const timestamp = (r?.timestamp) || 0;
+        const coverage = (r?.result) || [];
+        return { timestamp, coverage };
+    }
+    stopPreciseCoverage() {
+        this.#preciseCoverageDeltaUpdateCallback = null;
+        return this.#profilerAgent.invoke_stopPreciseCoverage();
+    }
+    preciseCoverageDeltaUpdate({ timestamp, result }) {
+        if (this.#preciseCoverageDeltaUpdateCallback) {
+            void this.#preciseCoverageDeltaUpdateCallback(timestamp, result);
+        }
+    }
+}
+SDKModel.register(CPUProfilerModel, { capabilities: 4 /* Capability.JS */, autostart: true });

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CPUThrottlingManager.js

@@ -0,0 +1,217 @@
+// Copyright 2017 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Common from '../../core/common/common.js';
+import * as i18n from '../i18n/i18n.js';
+import { EmulationModel } from './EmulationModel.js';
+import { TargetManager } from './TargetManager.js';
+const UIStrings = {
+    /**
+     * @description Text label for a menu item indicating that no throttling is applied.
+     */
+    noThrottling: 'No throttling',
+    /**
+     * @description Text label for a menu item indicating that a specific slowdown multiplier is applied.
+     * @example {2} PH1
+     */
+    dSlowdown: '{PH1}× slowdown',
+    /**
+     * @description Text label for a menu item indicating an average mobile device.
+     */
+    calibratedMidTierMobile: 'Mid-tier mobile',
+    /**
+     * @description Text label for a menu item indicating a below-average mobile device.
+     */
+    calibratedLowTierMobile: 'Low-tier mobile',
+    /**
+     * @description Text label indicating why an option is not available, because the user's device is not fast enough to emulate a device.
+     */
+    calibrationErrorDeviceTooWeak: 'Device is not powerful enough',
+};
+const str_ = i18n.i18n.registerUIStrings('core/sdk/CPUThrottlingManager.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
+let throttlingManagerInstance;
+export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper {
+    #cpuThrottlingOption;
+    #calibratedThrottlingSetting;
+    #hardwareConcurrency;
+    #pendingMainTargetPromise;
+    constructor() {
+        super();
+        this.#cpuThrottlingOption = NoThrottlingOption;
+        this.#calibratedThrottlingSetting = Common.Settings.Settings.instance().createSetting('calibrated-cpu-throttling', {}, "Global" /* Common.Settings.SettingStorageType.GLOBAL */);
+        this.#calibratedThrottlingSetting.addChangeListener(this.#onCalibratedSettingChanged, this);
+        TargetManager.instance().observeModels(EmulationModel, this);
+    }
+    static instance(opts = { forceNew: null }) {
+        const { forceNew } = opts;
+        if (!throttlingManagerInstance || forceNew) {
+            throttlingManagerInstance = new CPUThrottlingManager();
+        }
+        return throttlingManagerInstance;
+    }
+    cpuThrottlingRate() {
+        return this.#cpuThrottlingOption.rate();
+    }
+    cpuThrottlingOption() {
+        return this.#cpuThrottlingOption;
+    }
+    #onCalibratedSettingChanged() {
+        // If a calibrated option is selected, need to propagate new rate.
+        const currentOption = this.#cpuThrottlingOption;
+        if (!currentOption.calibratedDeviceType) {
+            return;
+        }
+        const rate = this.#cpuThrottlingOption.rate();
+        if (rate === 0) {
+            // This calibrated option is no longer valid.
+            this.setCPUThrottlingOption(NoThrottlingOption);
+            return;
+        }
+        for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
+            void emulationModel.setCPUThrottlingRate(rate);
+        }
+        this.dispatchEventToListeners("RateChanged" /* Events.RATE_CHANGED */, rate);
+    }
+    setCPUThrottlingOption(option) {
+        if (option === this.#cpuThrottlingOption) {
+            return;
+        }
+        this.#cpuThrottlingOption = option;
+        for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
+            void emulationModel.setCPUThrottlingRate(this.#cpuThrottlingOption.rate());
+        }
+        this.dispatchEventToListeners("RateChanged" /* Events.RATE_CHANGED */, this.#cpuThrottlingOption.rate());
+    }
+    setHardwareConcurrency(concurrency) {
+        this.#hardwareConcurrency = concurrency;
+        for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
+            void emulationModel.setHardwareConcurrency(concurrency);
+        }
+        this.dispatchEventToListeners("HardwareConcurrencyChanged" /* Events.HARDWARE_CONCURRENCY_CHANGED */, this.#hardwareConcurrency);
+    }
+    hasPrimaryPageTargetSet() {
+        // In some environments, such as Node, trying to check if we have a page
+        // target may error. So if we get any errors here at all, assume that we do
+        // not have a target.
+        try {
+            return TargetManager.instance().primaryPageTarget() !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getHardwareConcurrency() {
+        const target = TargetManager.instance().primaryPageTarget();
+        const existingCallback = this.#pendingMainTargetPromise;
+        // If the main target hasn't attached yet, block callers until it appears.
+        if (!target) {
+            if (existingCallback) {
+                return await new Promise(r => {
+                    this.#pendingMainTargetPromise = (result) => {
+                        r(result);
+                        existingCallback(result);
+                    };
+                });
+            }
+            return await new Promise(r => {
+                this.#pendingMainTargetPromise = r;
+            });
+        }
+        const evalResult = await target.runtimeAgent().invoke_evaluate({ expression: 'navigator.hardwareConcurrency', returnByValue: true, silent: true, throwOnSideEffect: true });
+        const error = evalResult.getError();
+        if (error) {
+            throw new Error(error);
+        }
+        const { result, exceptionDetails } = evalResult;
+        if (exceptionDetails) {
+            throw new Error(exceptionDetails.text);
+        }
+        return result.value;
+    }
+    modelAdded(emulationModel) {
+        if (this.#cpuThrottlingOption !== NoThrottlingOption) {
+            void emulationModel.setCPUThrottlingRate(this.#cpuThrottlingOption.rate());
+        }
+        if (this.#hardwareConcurrency !== undefined) {
+            void emulationModel.setHardwareConcurrency(this.#hardwareConcurrency);
+        }
+        // If there are any callers blocked on a getHardwareConcurrency call, let's wake them now.
+        if (this.#pendingMainTargetPromise) {
+            const existingCallback = this.#pendingMainTargetPromise;
+            this.#pendingMainTargetPromise = undefined;
+            void this.getHardwareConcurrency().then(existingCallback);
+        }
+    }
+    modelRemoved(_emulationModel) {
+        // Implemented as a requirement for being a SDKModelObserver.
+    }
+}
+export var CPUThrottlingRates;
+(function (CPUThrottlingRates) {
+    CPUThrottlingRates[CPUThrottlingRates["NO_THROTTLING"] = 1] = "NO_THROTTLING";
+    CPUThrottlingRates[CPUThrottlingRates["MID_TIER_MOBILE"] = 4] = "MID_TIER_MOBILE";
+    CPUThrottlingRates[CPUThrottlingRates["LOW_TIER_MOBILE"] = 6] = "LOW_TIER_MOBILE";
+    CPUThrottlingRates[CPUThrottlingRates["EXTRA_SLOW"] = 20] = "EXTRA_SLOW";
+    // eslint-disable-next-line @typescript-eslint/naming-convention -- Used by web_tests.
+    CPUThrottlingRates[CPUThrottlingRates["MidTierMobile"] = 4] = "MidTierMobile";
+    // eslint-disable-next-line @typescript-eslint/naming-convention -- Used by web_tests.
+    CPUThrottlingRates[CPUThrottlingRates["LowEndMobile"] = 6] = "LowEndMobile";
+})(CPUThrottlingRates || (CPUThrottlingRates = {}));
+function makeFixedPresetThrottlingOption(rate) {
+    return {
+        title: rate === 1 ? i18nLazyString(UIStrings.noThrottling) : i18nLazyString(UIStrings.dSlowdown, { PH1: rate }),
+        rate: () => rate,
+        jslogContext: rate === 1 ? 'cpu-no-throttling' : `cpu-throttled-${rate}`,
+    };
+}
+export const NoThrottlingOption = makeFixedPresetThrottlingOption(CPUThrottlingRates.NO_THROTTLING);
+export const MidTierThrottlingOption = makeFixedPresetThrottlingOption(CPUThrottlingRates.MID_TIER_MOBILE);
+export const LowTierThrottlingOption = makeFixedPresetThrottlingOption(CPUThrottlingRates.LOW_TIER_MOBILE);
+export const ExtraSlowThrottlingOption = makeFixedPresetThrottlingOption(CPUThrottlingRates.EXTRA_SLOW);
+function makeCalibratedThrottlingOption(calibratedDeviceType) {
+    const getSettingValue = () => {
+        const setting = Common.Settings.Settings.instance().createSetting('calibrated-cpu-throttling', {}, "Global" /* Common.Settings.SettingStorageType.GLOBAL */);
+        const value = setting.get();
+        if (calibratedDeviceType === 'low-tier-mobile') {
+            return value.low ?? null;
+        }
+        if (calibratedDeviceType === 'mid-tier-mobile') {
+            return value.mid ?? null;
+        }
+        return null;
+    };
+    return {
+        title() {
+            const typeString = calibratedDeviceType === 'low-tier-mobile' ? i18nString(UIStrings.calibratedLowTierMobile) :
+                i18nString(UIStrings.calibratedMidTierMobile);
+            const value = getSettingValue();
+            if (typeof value === 'number') {
+                return `${typeString} – ${value.toFixed(1)}×`;
+            }
+            return typeString;
+        },
+        rate() {
+            const value = getSettingValue();
+            if (typeof value === 'number') {
+                return value;
+            }
+            return 0;
+        },
+        calibratedDeviceType,
+        jslogContext: `cpu-throttled-calibrated-${calibratedDeviceType}`,
+    };
+}
+export const CalibratedLowTierMobileThrottlingOption = makeCalibratedThrottlingOption('low-tier-mobile');
+export const CalibratedMidTierMobileThrottlingOption = makeCalibratedThrottlingOption('mid-tier-mobile');
+export var CalibrationError;
+(function (CalibrationError) {
+    CalibrationError["DEVICE_TOO_WEAK"] = "DEVICE_TOO_WEAK";
+})(CalibrationError || (CalibrationError = {}));
+export function calibrationErrorToString(error) {
+    if (error === CalibrationError.DEVICE_TOO_WEAK) {
+        return i18nString(UIStrings.calibrationErrorDeviceTooWeak);
+    }
+    return error;
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CSSContainerQuery.js

@@ -0,0 +1,98 @@
+// Copyright 2021 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import { CSSQuery } from './CSSQuery.js';
+export class CSSContainerQuery extends CSSQuery {
+    name;
+    physicalAxes;
+    logicalAxes;
+    queriesScrollState;
+    queriesAnchored;
+    static parseContainerQueriesPayload(cssModel, payload) {
+        return payload.map(cq => new CSSContainerQuery(cssModel, cq));
+    }
+    constructor(cssModel, payload) {
+        super(cssModel);
+        this.reinitialize(payload);
+    }
+    reinitialize(payload) {
+        this.text = payload.text;
+        this.range = payload.range ? TextUtils.TextRange.TextRange.fromObject(payload.range) : null;
+        this.styleSheetId = payload.styleSheetId;
+        this.name = payload.name;
+        this.physicalAxes = payload.physicalAxes;
+        this.logicalAxes = payload.logicalAxes;
+        this.queriesScrollState = payload.queriesScrollState;
+        this.queriesAnchored = payload.queriesAnchored;
+    }
+    active() {
+        return true;
+    }
+    async getContainerForNode(nodeId) {
+        const containerNode = await this.cssModel.domModel().getContainerForNode(nodeId, this.name, this.physicalAxes, this.logicalAxes, this.queriesScrollState, this.queriesAnchored);
+        if (!containerNode) {
+            return;
+        }
+        return new CSSContainerQueryContainer(containerNode);
+    }
+}
+export class CSSContainerQueryContainer {
+    containerNode;
+    constructor(containerNode) {
+        this.containerNode = containerNode;
+    }
+    async getContainerSizeDetails() {
+        const styles = await this.containerNode.domModel().cssModel().getComputedStyle(this.containerNode.id);
+        if (!styles) {
+            return;
+        }
+        const containerType = styles.get('container-type');
+        const writingMode = styles.get('writing-mode');
+        if (!containerType || !writingMode) {
+            return;
+        }
+        const queryAxis = getQueryAxisFromContainerType(`${containerType}`);
+        const physicalAxis = getPhysicalAxisFromQueryAxis(queryAxis, writingMode);
+        let width, height;
+        if (physicalAxis === "Both" /* PhysicalAxis.BOTH */ || physicalAxis === "Horizontal" /* PhysicalAxis.HORIZONTAL */) {
+            width = styles.get('width');
+        }
+        if (physicalAxis === "Both" /* PhysicalAxis.BOTH */ || physicalAxis === "Vertical" /* PhysicalAxis.VERTICAL */) {
+            height = styles.get('height');
+        }
+        return {
+            queryAxis,
+            physicalAxis,
+            width,
+            height,
+        };
+    }
+}
+export const getQueryAxisFromContainerType = (propertyValue) => {
+    const segments = propertyValue.split(' ');
+    let isInline = false;
+    for (const segment of segments) {
+        if (segment === 'size') {
+            return "size" /* QueryAxis.BOTH */;
+        }
+        isInline = isInline || segment === 'inline-size';
+    }
+    if (isInline) {
+        return "inline-size" /* QueryAxis.INLINE */;
+    }
+    return "" /* QueryAxis.NONE */;
+};
+export const getPhysicalAxisFromQueryAxis = (queryAxis, writingMode) => {
+    const isVerticalWritingMode = writingMode.startsWith('vertical');
+    switch (queryAxis) {
+        case "" /* QueryAxis.NONE */:
+            return "" /* PhysicalAxis.NONE */;
+        case "size" /* QueryAxis.BOTH */:
+            return "Both" /* PhysicalAxis.BOTH */;
+        case "inline-size" /* QueryAxis.INLINE */:
+            return isVerticalWritingMode ? "Vertical" /* PhysicalAxis.VERTICAL */ : "Horizontal" /* PhysicalAxis.HORIZONTAL */;
+        case "block-size" /* QueryAxis.BLOCK */:
+            return isVerticalWritingMode ? "Horizontal" /* PhysicalAxis.HORIZONTAL */ : "Vertical" /* PhysicalAxis.VERTICAL */;
+    }
+};

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CSSFontFace.js

@@ -0,0 +1,31 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+export class CSSFontFace {
+    #fontFamily;
+    #fontVariationAxes;
+    #fontVariationAxesByTag = new Map();
+    #src;
+    #fontDisplay;
+    constructor(payload) {
+        this.#fontFamily = payload.fontFamily;
+        this.#fontVariationAxes = payload.fontVariationAxes || [];
+        this.#src = payload.src;
+        this.#fontDisplay = payload.fontDisplay;
+        for (const axis of this.#fontVariationAxes) {
+            this.#fontVariationAxesByTag.set(axis.tag, axis);
+        }
+    }
+    getFontFamily() {
+        return this.#fontFamily;
+    }
+    getSrc() {
+        return this.#src;
+    }
+    getFontDisplay() {
+        return this.#fontDisplay;
+    }
+    getVariationAxisByTag(tag) {
+        return this.#fontVariationAxesByTag.get(tag);
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CSSLayer.js

@@ -0,0 +1,22 @@
+// Copyright 2022 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import { CSSQuery } from './CSSQuery.js';
+export class CSSLayer extends CSSQuery {
+    static parseLayerPayload(cssModel, payload) {
+        return payload.map(supports => new CSSLayer(cssModel, supports));
+    }
+    constructor(cssModel, payload) {
+        super(cssModel);
+        this.reinitialize(payload);
+    }
+    reinitialize(payload) {
+        this.text = payload.text;
+        this.range = payload.range ? TextUtils.TextRange.TextRange.fromObject(payload.range) : null;
+        this.styleSheetId = payload.styleSheetId;
+    }
+    active() {
+        return true;
+    }
+}