@node-projects/web-component-designer 0.0.292 → 0.1.1

package/dist/elements/services/propertiesService/services/CssCurrentPropertiesService copy.js

@@ -1,105 +0,0 @@
-import { PropertyType } from '../PropertyType.js';
-import { RefreshMode } from '../IPropertiesService.js';
-import { CommonPropertiesService } from './CommonPropertiesService.js';
-import { ValueType } from '../ValueType.js';
-import { NodeType } from '../../../item/NodeType.js';
-//TODO: remove this code when import asserts are supported
-let cssProperties;
-//@ts-ignore
-if (window.importShim) {
-    const cssPropertiesUrl = import.meta.resolve('./CssProperties.json');
-    //@ts-ignore
-    cssProperties = await importShim(cssPropertiesUrl, { assert: { type: 'json' } });
-}
-else
-    //@ts-ignore
-    cssProperties = await import("./CssProperties.json", { assert: { type: 'json' } });
-if (cssProperties.default)
-    cssProperties = cssProperties.default;
-const localName = '<local>';
-export class CssCurrentPropertiesService extends CommonPropertiesService {
-    getRefreshMode(designItem) {
-        return RefreshMode.fullOnValueChange;
-    }
-    constructor() {
-        super();
-        this.name = 'styles';
-    }
-    isHandledElement(designItem) {
-        return true;
-    }
-    getProperty(designItem, name) {
-        return { name: name, type: 'string', service: this, propertyType: PropertyType.cssValue };
-    }
-    getProperties(designItem) {
-        if (!designItem || designItem.nodeType != NodeType.Element)
-            return [];
-        let styles = designItem.getAllStyles();
-        let arr = styles.map(x => ({
-            name: x.selector ?? localName, description: x.stylesheetName ?? '', properties: [
-                ...x.declarations.map(y => ({
-                    name: y.name,
-                    renamable: true,
-                    type: cssProperties[y.name]?.type ?? 'string',
-                    values: cssProperties[y.name]?.values ? [...cssProperties[y.name]?.values, 'initial', 'inherit', 'unset'] : ['initial', 'inherit', 'unset'],
-                    service: this,
-                    propertyType: PropertyType.cssValue,
-                    styleRule: x,
-                    styleDeclaration: y
-                })),
-                { name: '', type: 'addNew', service: this, propertyType: PropertyType.complex, styleRule: x }
-            ]
-        }));
-        return arr;
-    }
-    setValue(designItems, property, value) {
-        // No selector means local style, styleDeclaration is null means new property
-        if (property.styleRule?.selector !== null && property.styleDeclaration) {
-            // styleDeclaration stored Propertygrid is not refreshed after entering a new value, so we need to reload
-            // TODO: we do not respect if a same style is found in a media query or another @rule, maybe we need a refresh in the stylesheet parser
-            const decls = designItems[0].instanceServiceContainer.stylesheetService?.getDeclarations(designItems[0], property.styleDeclaration.name);
-            const currentDecl = decls.find(x => x.parent.selector == property.styleDeclaration.parent.selector && x.parent.stylesheetName == property.styleDeclaration.parent.stylesheetName);
-            designItems[0].instanceServiceContainer.stylesheetService.updateDeclarationValue(currentDecl, value, false);
-            this._notifyChangedProperty(designItems[0], property, value);
-            return;
-        }
-        if (property.styleRule?.selector !== null && !property.styleDeclaration) {
-            designItems[0].instanceServiceContainer.stylesheetService.insertDeclarationIntoRule(property.styleRule, property.name, value, false);
-            this._notifyChangedProperty(designItems[0], property, value);
-            return;
-        }
-        for (const d of designItems) {
-            // Local style
-            d.setStyle(property.name, value);
-            //unkown css property names do not trigger the mutation observer of property grid, 
-            //fixed by assinging stle again to the attribute
-            d.element.setAttribute('style', d.element.getAttribute('style'));
-        }
-    }
-    clearValue(designItems, property, clearType) {
-        if (property.styleRule?.selector !== null && property.styleDeclaration) {
-            designItems[0].instanceServiceContainer.stylesheetService.removeDeclarationFromRule(property.styleRule, property.styleDeclaration.name);
-            return;
-        }
-        super.clearValue(designItems, property, clearType);
-    }
-    getValue(designItems, property) {
-        if (property.styleRule?.selector && property.styleDeclaration)
-            return property.styleDeclaration.value;
-        return super.getValue(designItems, property);
-    }
-    getUnsetValue(designItems, property) {
-        if (property.styleRule?.selector && property.styleDeclaration)
-            return property.styleDeclaration.value;
-        return super.getUnsetValue(designItems, property);
-    }
-    isSet(designItems, property) {
-        if (property.styleRule?.selector && property.styleDeclaration) {
-            if (designItems[0].hasStyle(property.name))
-                return ValueType.none;
-            //TODO: we need to check if this is the dec. with the highest specifity
-            return ValueType.all;
-        }
-        return super.isSet(designItems, property);
-    }
-}

package/dist/elements/services/propertiesService/services/PolymerPropertiesService copy.d.ts

@@ -1,8 +0,0 @@
-import { IProperty } from '../IProperty.js';
-import { IDesignItem } from '../../../item/IDesignItem.js';
-import { AbstractPolymerLikePropertiesService } from './AbstractPolymerLikePropertiesService.js';
-export declare class PolymerPropertiesService extends AbstractPolymerLikePropertiesService {
-    name: string;
-    isHandledElement(designItem: IDesignItem): boolean;
-    protected _notifyChangedProperty(designItem: IDesignItem, property: IProperty, value: any): void;
-}

package/dist/elements/services/propertiesService/services/PolymerPropertiesService copy.js

@@ -1,10 +0,0 @@
-import { AbstractPolymerLikePropertiesService } from './AbstractPolymerLikePropertiesService.js';
-export class PolymerPropertiesService extends AbstractPolymerLikePropertiesService {
-    name = "polymer";
-    isHandledElement(designItem) {
-        return designItem.element.constructor.polymerElementVersion != null;
-    }
-    _notifyChangedProperty(designItem, property, value) {
-        designItem.element.set(property.name, value);
-    }
-}

package/dist/elements/services/propertiesService/services/UnkownElemntPropertiesService.d.ts

@@ -1,24 +0,0 @@
-/// <reference types="node" />
-import { IPropertiesService, RefreshMode } from '../IPropertiesService.js';
-import { IProperty } from '../IProperty.js';
-import { IDesignItem } from '../../../item/IDesignItem.js';
-import { ValueType } from '../ValueType.js';
-import { BindingTarget } from '../../../item/BindingTarget.js';
-import { IBinding } from '../../../item/IBinding.js';
-import { IPropertyGroup } from '../IPropertyGroup.js';
-export declare abstract class AbstractPropertiesService implements IPropertiesService {
-    _stylesCache: Map<IDesignItem, Set<string>>;
-    _cacheClearTimer: NodeJS.Timeout;
-    abstract getRefreshMode(designItem: IDesignItem): RefreshMode;
-    abstract isHandledElement(designItem: IDesignItem): boolean;
-    protected _notifyChangedProperty(designItem: IDesignItem, property: IProperty, value: any): void;
-    getProperty(designItem: IDesignItem, name: string): IProperty;
-    getProperties(designItem: IDesignItem): IProperty[] | IPropertyGroup[];
-    setValue(designItems: IDesignItem[], property: IProperty, value: any): void;
-    getPropertyTarget(designItem: IDesignItem, property: IProperty): BindingTarget;
-    clearValue(designItems: IDesignItem[], property: IProperty, clearType: 'all' | 'binding' | 'value'): void;
-    isSet(designItems: IDesignItem[], property: IProperty): ValueType;
-    getValue(designItems: IDesignItem[], property: IProperty): string | boolean;
-    getBinding(designItems: IDesignItem[], property: IProperty): IBinding;
-    getUnsetValue(designItems: IDesignItem[], property: IProperty): any;
-}

package/dist/elements/services/propertiesService/services/UnkownElemntPropertiesService.js

@@ -1,198 +0,0 @@
-import { ValueType } from '../ValueType.js';
-import { PropertiesHelper } from './PropertiesHelper.js';
-import { BindingTarget } from '../../../item/BindingTarget.js';
-import { PropertyType } from '../PropertyType.js';
-import { NodeType } from '../../../item/NodeType.js';
-export class AbstractPropertiesService {
-    _stylesCache = new Map;
-    _cacheClearTimer;
-    _notifyChangedProperty(designItem, property, value) {
-    }
-    getProperty(designItem, name) {
-        let properties = this.getProperties(designItem);
-        if ('properties' in properties[0]) {
-            return properties.flatMap(x => x.properties).find(x => x.name == name);
-        }
-        else
-            return properties.find(x => x.name == name);
-    }
-    getProperties(designItem) {
-        Object.getOwnPropertyNames(Object.getPrototypeOf(designItem.element));
-    }
-    setValue(designItems, property, value) {
-        const cg = designItems[0].openGroup("property changed: " + property.name + " to " + value);
-        for (let d of designItems) {
-            if (property.propertyType == PropertyType.cssValue) {
-                d.updateStyleInSheetOrLocal(property.name, value);
-                //unkown css property names do not trigger the mutation observer of property grid, 
-                //fixed by assinging stle again to the attribute
-                d.element.setAttribute('style', d.element.getAttribute('style'));
-            }
-            else {
-                let attributeName = property.attributeName;
-                if (!attributeName)
-                    attributeName = PropertiesHelper.camelToDashCase(property.name);
-                if (property.type === 'object') {
-                    const json = JSON.stringify(value);
-                    if (property.propertyType == PropertyType.attribute || property.propertyType == PropertyType.propertyAndAttribute)
-                        d.setAttribute(attributeName, json);
-                    if (property.propertyType == PropertyType.property || property.propertyType == PropertyType.propertyAndAttribute)
-                        d.element[property.name] = value;
-                }
-                else if (property.type == 'boolean' && !value) {
-                    if (property.propertyType == PropertyType.attribute || property.propertyType == PropertyType.propertyAndAttribute)
-                        d.removeAttribute(attributeName);
-                    if (property.propertyType == PropertyType.property || property.propertyType == PropertyType.propertyAndAttribute)
-                        d.element[property.name] = false;
-                }
-                else if (property.type == 'boolean' && value) {
-                    if (property.propertyType == PropertyType.attribute || property.propertyType == PropertyType.propertyAndAttribute)
-                        d.setAttribute(attributeName, "");
-                    if (property.propertyType == PropertyType.property || property.propertyType == PropertyType.propertyAndAttribute)
-                        d.element[property.name] = true;
-                }
-                else {
-                    if (property.propertyType == PropertyType.attribute || property.propertyType == PropertyType.propertyAndAttribute)
-                        d.setAttribute(attributeName, value.toString());
-                    if (property.propertyType == PropertyType.property || property.propertyType == PropertyType.propertyAndAttribute)
-                        d.element[property.name] = value;
-                }
-            }
-            this._notifyChangedProperty(d, property, value);
-        }
-        cg.commit();
-    }
-    getPropertyTarget(designItem, property) {
-        return BindingTarget.property;
-    }
-    clearValue(designItems, property, clearType) {
-        const cg = designItems[0].openGroup("property cleared: " + property.name);
-        for (let d of designItems) {
-            if (clearType != 'binding') {
-                if (property.propertyType == PropertyType.cssValue) {
-                    d.removeStyle(property.name);
-                }
-                else {
-                    let attributeName = property.attributeName;
-                    if (!attributeName)
-                        attributeName = PropertiesHelper.camelToDashCase(property.name);
-                    d.removeAttribute(attributeName);
-                }
-            }
-            if (clearType != 'value') {
-                d.serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
-                    return s.clearBinding(d, property.name, this.getPropertyTarget(d, property));
-                });
-            }
-            this._notifyChangedProperty(d, property, undefined);
-        }
-        cg.commit();
-    }
-    isSet(designItems, property) {
-        let all = true;
-        let some = false;
-        if (designItems != null && designItems.length !== 0) {
-            let attributeName = property.attributeName;
-            if (!attributeName)
-                attributeName = PropertiesHelper.camelToDashCase(property.name);
-            for (let x of designItems) {
-                let has = false;
-                if (property.propertyType == PropertyType.cssValue)
-                    has = x.hasStyle(property.name);
-                else
-                    has = x.hasAttribute(attributeName);
-                all = all && has;
-                some = some || has;
-                if (!all && some)
-                    break;
-            }
-            ;
-            //todo: optimize perf, do not call bindings service for each property. 
-            const bindings = designItems[0].serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
-                return s.getBindings(designItems[0]);
-            });
-            if (property.propertyType == PropertyType.cssValue) {
-                if (bindings && bindings.find(x => x.target == BindingTarget.css && x.targetName == property.name))
-                    return ValueType.bound;
-            }
-            else {
-                if (bindings && bindings.find(x => x.target == BindingTarget.property && x.targetName == property.name))
-                    return ValueType.bound;
-            }
-            if (!all && property.propertyType == PropertyType.cssValue) {
-                let styles = this._stylesCache.get(designItems[0]);
-                if (!styles) {
-                    styles = new Set(designItems[0].getAllStyles().filter(x => x.selector != null).flatMap(x => x.declarations).map(x => x.name));
-                    this._stylesCache.set(designItems[0], styles);
-                    clearTimeout(this._cacheClearTimer);
-                    this._cacheClearTimer = setTimeout(() => this._stylesCache.clear(), 30);
-                }
-                let cssValue = styles.has(property.name);
-                if (cssValue)
-                    return ValueType.fromStylesheet;
-            }
-        }
-        else
-            return ValueType.none;
-        return all ? ValueType.all : some ? ValueType.some : ValueType.none;
-    }
-    getValue(designItems, property) {
-        if (designItems != null && designItems.length !== 0) {
-            if (property.propertyType == PropertyType.cssValue) {
-                let lastValue = designItems[0].getStyle(property.name);
-                for (const d of designItems) {
-                    let value = d.getStyle(property.name);
-                    if (value != lastValue) {
-                        lastValue = null;
-                        break;
-                    }
-                }
-                return lastValue;
-            }
-            else {
-                let attributeName = property.attributeName;
-                if (!attributeName)
-                    attributeName = PropertiesHelper.camelToDashCase(property.name);
-                if (property.type == 'boolean')
-                    return designItems[0].hasAttribute(attributeName);
-                let lastValue = designItems[0].getAttribute(attributeName);
-                /*
-                for (const x of designItems) {
-                  let value = x.attributes.get(attributeName);
-                  if (value != lastValue) {
-                    lastValue = null;
-                    break;
-                  }
-                }
-                */
-                return lastValue;
-            }
-        }
-        return null;
-    }
-    getBinding(designItems, property) {
-        //TODO: optimize perf, do not call bindings service for each property. 
-        const bindings = designItems[0].serviceContainer.forSomeServicesTillResult('bindingService', (s) => {
-            return s.getBindings(designItems[0]);
-        });
-        if (property.propertyType == PropertyType.cssValue) {
-            return bindings.find(x => (x.target == BindingTarget.css) && x.targetName == property.name);
-        }
-        else {
-            return bindings.find(x => (x.target == BindingTarget.property || x.target == BindingTarget.attribute) && x.targetName == property.name);
-        }
-    }
-    getUnsetValue(designItems, property) {
-        if (property.propertyType == PropertyType.cssValue) {
-            if (designItems != null && designItems.length !== 0) {
-                if (designItems[0].nodeType == NodeType.Element) {
-                    let v = window.getComputedStyle(designItems[0].element)[property.name];
-                    return v;
-                }
-            }
-            return null;
-        }
-        else
-            return property.defaultValue;
-    }
-}

package/dist/elements/services/stylesheetService/CssToolsStylesheetService.d.ts

@@ -1,42 +0,0 @@
-import { IDesignItem } from "../../item/IDesignItem.js";
-import { IStyleDeclaration, IStyleRule, IStylesheet } from "./IStylesheetService.js";
-import { AbstractStylesheetService } from "./AbstractStylesheetService.js";
-import { IDesignerCanvas } from "../../widgets/designerView/IDesignerCanvas.js";
-type CssRuleAST = any;
-type CssDeclarationAST = any;
-type CssStylesheetAST = any;
-interface IRuleWithAST extends IStyleRule {
-    ast: CssRuleAST;
-    declarations: IDeclarationWithAST[];
-    stylesheet: IStylesheet;
-    stylesheetName: string;
-}
-interface IDeclarationWithAST extends IStyleDeclaration {
-    ast: CssDeclarationAST;
-}
-export declare class CssToolsStylesheetService extends AbstractStylesheetService {
-    constructor(designerCanvas: IDesignerCanvas);
-    _tools: {
-        parse: (css: string, options?: {
-            source?: string;
-            silent?: boolean;
-        }) => CssStylesheetAST;
-        stringify: (node: CssStylesheetAST, options?: {
-            indent?: string;
-            compress?: boolean;
-            emptyDeclarations?: boolean;
-        }) => string;
-    };
-    internalParse(style: string): Promise<any>;
-    getAppliedRules(designItem: IDesignItem): IRuleWithAST[];
-    private getRulesFromAst;
-    getDeclarations(designItem: IDesignItem, styleName: string): IStyleDeclaration[];
-    updateDeclarationValueWithoutUndo(declaration: IDeclarationWithAST, value: string, important: boolean): void;
-    insertDeclarationIntoRule(rule: IRuleWithAST, property: string, value: string, important: boolean): boolean;
-    removeDeclarationFromRule(rule: IRuleWithAST, property: string): boolean;
-    private updateStylesheet;
-    updateCompleteStylesheet(name: string, newStyle: string): void;
-    updateCompleteStylesheetWithoutUndo(name: string, newStyle: string, noUndo?: boolean): void;
-    private updateCompleteStylesheetInternal;
-}
-export {};

package/dist/elements/services/stylesheetService/CssToolsStylesheetService.js

@@ -1,114 +0,0 @@
-import { AbstractStylesheetService } from "./AbstractStylesheetService.js";
-export class CssToolsStylesheetService extends AbstractStylesheetService {
-    constructor(designerCanvas) {
-        super(designerCanvas);
-    }
-    _tools;
-    async internalParse(style) {
-        if (!this._tools)
-            this._tools = await import('@adobe/css-tools');
-        return this._tools.parse(style);
-    }
-    getAppliedRules(designItem) {
-        let rules = [];
-        for (let item of this._allStylesheets.entries()) {
-            if (!item[1].ast?.stylesheet?.rules)
-                continue;
-            let rs = Array.from(this.getRulesFromAst(item[1].ast?.stylesheet?.rules, item[1].stylesheet, designItem))
-                .map(x => ({
-                selector: x.selectors.join(', '),
-                declarations: x.declarations.filter(y => y.type == 'declaration').map(y => ({
-                    name: y.property,
-                    value: y.value.endsWith('!important') ? y.value.substring(0, y.value.length - 10).trimEnd() : y.value,
-                    important: y.value.endsWith('!important'),
-                    parent: null,
-                    ast: y,
-                    stylesheet: item[1].stylesheet
-                })),
-                specificity: 0,
-                stylesheetName: item[0],
-                ast: x,
-            }));
-            rs.forEach(x => x.declarations.forEach(y => y.parent = x));
-            rules.push(...rs);
-        }
-        ;
-        return rules;
-    }
-    *getRulesFromAst(cssAtRuleAst, stylesheet, designItem) {
-        for (const atRule of cssAtRuleAst) {
-            if (atRule.type == 'media') {
-                yield* this.getRulesFromAst(atRule.rules, stylesheet, designItem);
-            }
-            else if (atRule.type == 'supports') {
-                yield* this.getRulesFromAst(atRule.rules, stylesheet, designItem);
-            }
-            else if (atRule.type == 'rule') {
-                if (this.elementMatchesASelector(designItem, atRule.selectors))
-                    yield atRule;
-            }
-        }
-        return null;
-    }
-    getDeclarations(designItem, styleName) {
-        return this.getAppliedRules(designItem).flatMap(x => x.declarations).filter(x => x.name == styleName);
-    }
-    updateDeclarationValueWithoutUndo(declaration, value, important) {
-        declaration.ast.value = important ? value + ' !important' : value;
-        let ss = this._allStylesheets.get(declaration.parent.stylesheetName);
-        this.updateStylesheet(ss);
-        /*
-        declaration.ast.value = important ? value + ' !important' : value;
-        let ss = declaration.ast;
-        while (ss?.parent)
-            ss = ss?.parent;
-        let obj = { ast: ss, stylesheet: declaration.stylesheet };
-        this._allStylesheets.set(declaration.parent.stylesheetName, obj)
-        this.updateStylesheet(obj);
-        */
-    }
-    insertDeclarationIntoRule(rule, property, value, important) {
-        rule.ast.declarations.push({
-            type: 'declaration',
-            property: property,
-            value: important ? value + ' !important' : value
-        });
-        this.updateStylesheet(this._allStylesheets.get(rule.stylesheetName));
-        return true;
-    }
-    removeDeclarationFromRule(rule, property) {
-        let idx = rule.ast.declarations.findIndex(x => x.property == property);
-        if (idx == -1)
-            return false;
-        rule.ast.declarations.splice(idx, 1);
-        this.updateStylesheet(this._allStylesheets.get(rule.stylesheetName));
-        return true;
-    }
-    updateStylesheet(ss) {
-        const old = ss.stylesheet.content;
-        ss.stylesheet.content = this._tools.stringify(ss.ast, { indent: '    ', compress: false, emptyDeclarations: true });
-        if (ss.stylesheet.designItem) {
-            ss.stylesheet.designItem.content = ss.stylesheet.content;
-        }
-        else
-            this.stylesheetChanged.emit({ name: ss.stylesheet.name, newStyle: ss.stylesheet.content, oldStyle: old, changeSource: 'styleupdate' });
-    }
-    updateCompleteStylesheet(name, newStyle) {
-        this.updateCompleteStylesheetInternal(name, newStyle, 'styleupdate');
-    }
-    updateCompleteStylesheetWithoutUndo(name, newStyle, noUndo = false) {
-        this.updateCompleteStylesheetInternal(name, newStyle, 'undo');
-    }
-    updateCompleteStylesheetInternal(name, newStyle, changeSource) {
-        const ss = this._allStylesheets.get(name);
-        if (ss.stylesheet.content != newStyle) {
-            const old = ss.stylesheet.content;
-            ss.stylesheet.content = newStyle;
-            if (ss.stylesheet.designItem) {
-                ss.stylesheet.designItem.content = ss.stylesheet.content;
-            }
-            else
-                this.stylesheetChanged.emit({ name: ss.stylesheet.name, newStyle: ss.stylesheet.content, oldStyle: old, changeSource });
-        }
-    }
-}

package/dist/elements/services/stylesheetService/CssTreeStylesheetService.d.ts

@@ -1,58 +0,0 @@
-import { IDesignItem } from "../../item/IDesignItem.js";
-import { IStyleDeclaration, IStyleRule, IStylesheet } from "./IStylesheetService.js";
-import { AbstractStylesheetService } from "./AbstractStylesheetService.js";
-import { IDesignerCanvas } from "../../widgets/designerView/IDesignerCanvas.js";
-declare namespace csstree {
-    type CssNodePlain = any;
-    type CssNode = any;
-    type ParseOptions = any;
-    type GenerateOptions = any;
-    type RulePlain = any;
-    type DeclarationPlain = any;
-    type StyleSheetPlain = any;
-    type Raw = any;
-    type Declaration = any;
-    type AtrulePlain = any;
-    type BlockPlain = any;
-    type SelectorListPlain = any;
-}
-declare global {
-    interface Window {
-        csstree: {
-            fromPlainObject(node: csstree.CssNodePlain): csstree.CssNode;
-            toPlainObject(node: csstree.CssNode): csstree.CssNodePlain;
-            parse(text: string, options?: csstree.ParseOptions): csstree.CssNode;
-            generate(ast: csstree.CssNode, options?: csstree.GenerateOptions): string;
-        };
-    }
-}
-interface IRuleWithAST extends IStyleRule {
-    ast: csstree.RulePlain;
-    declarations: IDeclarationWithAST[];
-    stylesheet: IStylesheet;
-}
-interface IDeclarationWithAST extends IStyleDeclaration {
-    ast: csstree.DeclarationPlain;
-}
-export declare class CssTreeStylesheetService extends AbstractStylesheetService {
-    constructor(designerCanvas: IDesignerCanvas);
-    internalParse(style: string): Promise<any>;
-    private getAppliedRulesInternal;
-    getAppliedRules(designItem: IDesignItem): IRuleWithAST[];
-    private getDeclarationInternal;
-    getDeclarations(designItem: IDesignItem, stlyeName: string): IDeclarationWithAST[];
-    updateDeclarationValueWithoutUndo(declaration: IDeclarationWithAST, value: string, important: boolean): void;
-    insertDeclarationIntoRule(rule: IRuleWithAST, property: string, value: string, important: boolean): boolean;
-    removeDeclarationFromRule(rule: IRuleWithAST, property: string): boolean;
-    updateCompleteStylesheet(name: string, newStyle: string): void;
-    updateCompleteStylesheetWithoutUndo(name: string, newStyle: string, noUndo?: boolean): void;
-    private updateCompleteStylesheetInternal;
-    private rulesFromAST;
-    private astHasChildren;
-    private buildSelectorString;
-    private getSpecificity;
-    private findDeclarationInRule;
-    private buildAtRuleString;
-    private sortDeclarations;
-}
-export {};