@cj-tech-master/excelts 4.0.0 → 4.0.1

package/dist/browser/modules/excel/xlsx/xform/core/app-xform.js

@@ -0,0 +1,83 @@
+import { XmlStream } from "../../../utils/xml-stream.js";
+import { BaseXform } from "../base-xform.js";
+import { StringXform } from "../simple/string-xform.js";
+import { AppHeadingPairsXform } from "./app-heading-pairs-xform.js";
+import { AppTitlesOfPartsXform } from "./app-titles-of-parts-xform.js";
+class AppXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            Company: new StringXform({ tag: "Company" }),
+            Manager: new StringXform({ tag: "Manager" }),
+            HeadingPairs: new AppHeadingPairsXform(),
+            TitleOfParts: new AppTitlesOfPartsXform()
+        };
+    }
+    render(xmlStream, model) {
+        xmlStream.openXml(XmlStream.StdDocAttributes);
+        xmlStream.openNode("Properties", AppXform.PROPERTY_ATTRIBUTES);
+        xmlStream.leafNode("Application", undefined, "Microsoft Excel");
+        xmlStream.leafNode("DocSecurity", undefined, "0");
+        xmlStream.leafNode("ScaleCrop", undefined, "false");
+        this.map.HeadingPairs.render(xmlStream, model.worksheets);
+        this.map.TitleOfParts.render(xmlStream, model.worksheets);
+        this.map.Company.render(xmlStream, model.company || "");
+        this.map.Manager.render(xmlStream, model.manager);
+        xmlStream.leafNode("LinksUpToDate", undefined, "false");
+        xmlStream.leafNode("SharedDoc", undefined, "false");
+        xmlStream.leafNode("HyperlinksChanged", undefined, "false");
+        xmlStream.leafNode("AppVersion", undefined, "16.0300");
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case "Properties":
+                return true;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                    return true;
+                }
+                // there's a lot we don't bother to parse
+                return false;
+        }
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case "Properties":
+                this.model = {
+                    worksheets: this.map.TitleOfParts.model,
+                    company: this.map.Company.model,
+                    manager: this.map.Manager.model
+                };
+                return false;
+            default:
+                return true;
+        }
+    }
+}
+AppXform.DateFormat = function (dt) {
+    return dt.toISOString().replace(/[.]\d{3,6}/, "");
+};
+AppXform.DateAttrs = { "xsi:type": "dcterms:W3CDTF" };
+AppXform.PROPERTY_ATTRIBUTES = {
+    xmlns: "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties",
+    "xmlns:vt": "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"
+};
+export { AppXform };

package/dist/browser/modules/excel/xlsx/xform/core/content-types-xform.d.ts

@@ -0,0 +1,11 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+declare class ContentTypesXform extends BaseXform {
+    render(xmlStream: any, model: any): void;
+    parseOpen(): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+    static PROPERTY_ATTRIBUTES: {
+        xmlns: string;
+    };
+}
+export { ContentTypesXform };

package/dist/browser/modules/excel/xlsx/xform/core/content-types-xform.js

@@ -0,0 +1,122 @@
+import { XmlStream } from "../../../utils/xml-stream.js";
+import { BaseXform } from "../base-xform.js";
+import { OOXML_PATHS, commentsPathFromName, drawingPath, pivotCacheDefinitionPath, pivotCacheRecordsPath, pivotTablePath, tablePath, toContentTypesPartName, worksheetPath } from "../../../utils/ooxml-paths.js";
+// used for rendering the [Content_Types].xml file
+// not used for parsing
+class ContentTypesXform extends BaseXform {
+    render(xmlStream, model) {
+        xmlStream.openXml(XmlStream.StdDocAttributes);
+        xmlStream.openNode("Types", ContentTypesXform.PROPERTY_ATTRIBUTES);
+        const mediaHash = {};
+        (model.media || []).forEach((medium) => {
+            if (medium.type === "image") {
+                const imageType = medium.extension;
+                if (!mediaHash[imageType]) {
+                    mediaHash[imageType] = true;
+                    xmlStream.leafNode("Default", {
+                        Extension: imageType,
+                        ContentType: `image/${imageType}`
+                    });
+                }
+            }
+        });
+        xmlStream.leafNode("Default", {
+            Extension: "rels",
+            ContentType: "application/vnd.openxmlformats-package.relationships+xml"
+        });
+        xmlStream.leafNode("Default", { Extension: "xml", ContentType: "application/xml" });
+        xmlStream.leafNode("Override", {
+            PartName: toContentTypesPartName(OOXML_PATHS.xlWorkbook),
+            ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"
+        });
+        model.worksheets.forEach((worksheet, index) => {
+            // Use fileIndex if set, otherwise use sequential index (1-based)
+            const fileIndex = worksheet.fileIndex || index + 1;
+            xmlStream.leafNode("Override", {
+                PartName: toContentTypesPartName(worksheetPath(fileIndex)),
+                ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"
+            });
+        });
+        if ((model.pivotTables || []).length) {
+            // Add content types for each pivot table
+            (model.pivotTables || []).forEach((pivotTable) => {
+                const n = pivotTable.tableNumber;
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(pivotCacheDefinitionPath(n)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml"
+                });
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(pivotCacheRecordsPath(n)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml"
+                });
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(pivotTablePath(n)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml"
+                });
+            });
+        }
+        xmlStream.leafNode("Override", {
+            PartName: toContentTypesPartName(OOXML_PATHS.xlTheme1),
+            ContentType: "application/vnd.openxmlformats-officedocument.theme+xml"
+        });
+        xmlStream.leafNode("Override", {
+            PartName: toContentTypesPartName(OOXML_PATHS.xlStyles),
+            ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"
+        });
+        const hasSharedStrings = model.sharedStrings && model.sharedStrings.count;
+        if (hasSharedStrings) {
+            xmlStream.leafNode("Override", {
+                PartName: toContentTypesPartName(OOXML_PATHS.xlSharedStrings),
+                ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"
+            });
+        }
+        if (model.tables) {
+            model.tables.forEach((table) => {
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(tablePath(table.target)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml"
+                });
+            });
+        }
+        if (model.drawings) {
+            model.drawings.forEach((drawing) => {
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(drawingPath(drawing.name)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.drawing+xml"
+                });
+            });
+        }
+        if (model.commentRefs) {
+            xmlStream.leafNode("Default", {
+                Extension: "vml",
+                ContentType: "application/vnd.openxmlformats-officedocument.vmlDrawing"
+            });
+            model.commentRefs.forEach(({ commentName }) => {
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(commentsPathFromName(commentName)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml"
+                });
+            });
+        }
+        xmlStream.leafNode("Override", {
+            PartName: toContentTypesPartName(OOXML_PATHS.docPropsCore),
+            ContentType: "application/vnd.openxmlformats-package.core-properties+xml"
+        });
+        xmlStream.leafNode("Override", {
+            PartName: toContentTypesPartName(OOXML_PATHS.docPropsApp),
+            ContentType: "application/vnd.openxmlformats-officedocument.extended-properties+xml"
+        });
+        xmlStream.closeNode();
+    }
+    parseOpen() {
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+ContentTypesXform.PROPERTY_ATTRIBUTES = {
+    xmlns: "http://schemas.openxmlformats.org/package/2006/content-types"
+};
+export { ContentTypesXform };

package/dist/browser/modules/excel/xlsx/xform/core/core-xform.d.ts

@@ -0,0 +1,42 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface CoreModel {
+    creator?: string;
+    title?: string;
+    subject?: string;
+    description?: string;
+    identifier?: string;
+    language?: string;
+    keywords?: string;
+    category?: string;
+    lastModifiedBy?: string;
+    lastPrinted?: Date;
+    revision?: number;
+    version?: string;
+    contentStatus?: string;
+    contentType?: string;
+    created?: Date;
+    modified?: Date;
+}
+declare class CoreXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    constructor();
+    render(xmlStream: any, model: CoreModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    static DateFormat: (dt: Date) => string;
+    static DateAttrs: {
+        "xsi:type": string;
+    };
+    static CORE_PROPERTY_ATTRIBUTES: {
+        "xmlns:cp": string;
+        "xmlns:dc": string;
+        "xmlns:dcterms": string;
+        "xmlns:dcmitype": string;
+        "xmlns:xsi": string;
+    };
+}
+export { CoreXform };

package/dist/browser/modules/excel/xlsx/xform/core/core-xform.js

@@ -0,0 +1,124 @@
+import { XmlStream } from "../../../utils/xml-stream.js";
+import { BaseXform } from "../base-xform.js";
+import { DateXform } from "../simple/date-xform.js";
+import { StringXform } from "../simple/string-xform.js";
+import { IntegerXform } from "../simple/integer-xform.js";
+class CoreXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            "dc:creator": new StringXform({ tag: "dc:creator" }),
+            "dc:title": new StringXform({ tag: "dc:title" }),
+            "dc:subject": new StringXform({ tag: "dc:subject" }),
+            "dc:description": new StringXform({ tag: "dc:description" }),
+            "dc:identifier": new StringXform({ tag: "dc:identifier" }),
+            "dc:language": new StringXform({ tag: "dc:language" }),
+            "cp:keywords": new StringXform({ tag: "cp:keywords" }),
+            "cp:category": new StringXform({ tag: "cp:category" }),
+            "cp:lastModifiedBy": new StringXform({ tag: "cp:lastModifiedBy" }),
+            "cp:lastPrinted": new DateXform({ tag: "cp:lastPrinted", format: CoreXform.DateFormat }),
+            "cp:revision": new IntegerXform({ tag: "cp:revision" }),
+            "cp:version": new StringXform({ tag: "cp:version" }),
+            "cp:contentStatus": new StringXform({ tag: "cp:contentStatus" }),
+            "cp:contentType": new StringXform({ tag: "cp:contentType" }),
+            "dcterms:created": new DateXform({
+                tag: "dcterms:created",
+                attrs: CoreXform.DateAttrs,
+                format: CoreXform.DateFormat
+            }),
+            "dcterms:modified": new DateXform({
+                tag: "dcterms:modified",
+                attrs: CoreXform.DateAttrs,
+                format: CoreXform.DateFormat
+            })
+        };
+    }
+    render(xmlStream, model) {
+        xmlStream.openXml(XmlStream.StdDocAttributes);
+        xmlStream.openNode("cp:coreProperties", CoreXform.CORE_PROPERTY_ATTRIBUTES);
+        this.map["dc:creator"].render(xmlStream, model.creator);
+        this.map["dc:title"].render(xmlStream, model.title);
+        this.map["dc:subject"].render(xmlStream, model.subject);
+        this.map["dc:description"].render(xmlStream, model.description);
+        this.map["dc:identifier"].render(xmlStream, model.identifier);
+        this.map["dc:language"].render(xmlStream, model.language);
+        this.map["cp:keywords"].render(xmlStream, model.keywords);
+        this.map["cp:category"].render(xmlStream, model.category);
+        this.map["cp:lastModifiedBy"].render(xmlStream, model.lastModifiedBy);
+        this.map["cp:lastPrinted"].render(xmlStream, model.lastPrinted);
+        this.map["cp:revision"].render(xmlStream, model.revision);
+        this.map["cp:version"].render(xmlStream, model.version);
+        this.map["cp:contentStatus"].render(xmlStream, model.contentStatus);
+        this.map["cp:contentType"].render(xmlStream, model.contentType);
+        this.map["dcterms:created"].render(xmlStream, model.created);
+        this.map["dcterms:modified"].render(xmlStream, model.modified);
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case "cp:coreProperties":
+            case "coreProperties":
+                return true;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                    return true;
+                }
+                throw new Error(`Unexpected xml node in parseOpen: ${JSON.stringify(node)}`);
+        }
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case "cp:coreProperties":
+            case "coreProperties":
+                this.model = {
+                    creator: this.map["dc:creator"].model,
+                    title: this.map["dc:title"].model,
+                    subject: this.map["dc:subject"].model,
+                    description: this.map["dc:description"].model,
+                    identifier: this.map["dc:identifier"].model,
+                    language: this.map["dc:language"].model,
+                    keywords: this.map["cp:keywords"].model,
+                    category: this.map["cp:category"].model,
+                    lastModifiedBy: this.map["cp:lastModifiedBy"].model,
+                    lastPrinted: this.map["cp:lastPrinted"].model,
+                    revision: this.map["cp:revision"].model,
+                    contentStatus: this.map["cp:contentStatus"].model,
+                    contentType: this.map["cp:contentType"].model,
+                    created: this.map["dcterms:created"].model,
+                    modified: this.map["dcterms:modified"].model
+                };
+                return false;
+            default:
+                throw new Error(`Unexpected xml node in parseClose: ${name}`);
+        }
+    }
+}
+CoreXform.DateFormat = function (dt) {
+    return dt.toISOString().replace(/[.]\d{3}/, "");
+};
+CoreXform.DateAttrs = { "xsi:type": "dcterms:W3CDTF" };
+CoreXform.CORE_PROPERTY_ATTRIBUTES = {
+    "xmlns:cp": "http://schemas.openxmlformats.org/package/2006/metadata/core-properties",
+    "xmlns:dc": "http://purl.org/dc/elements/1.1/",
+    "xmlns:dcterms": "http://purl.org/dc/terms/",
+    "xmlns:dcmitype": "http://purl.org/dc/dcmitype/",
+    "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance"
+};
+export { CoreXform };

package/dist/browser/modules/excel/xlsx/xform/core/relationship-xform.d.ts

@@ -0,0 +1,14 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface RelationshipModel {
+    Id?: string;
+    Type?: string;
+    Target?: string;
+    TargetMode?: string;
+}
+declare class RelationshipXform extends BaseXform {
+    render(xmlStream: any, model: RelationshipModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { RelationshipXform };

package/dist/browser/modules/excel/xlsx/xform/core/relationship-xform.js

@@ -0,0 +1,20 @@
+import { BaseXform } from "../base-xform.js";
+class RelationshipXform extends BaseXform {
+    render(xmlStream, model) {
+        xmlStream.leafNode("Relationship", model);
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case "Relationship":
+                this.model = node.attributes;
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { RelationshipXform };

package/dist/browser/modules/excel/xlsx/xform/core/relationships-xform.d.ts

@@ -0,0 +1,14 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+declare class RelationshipsXform extends BaseXform {
+    parser: any;
+    private _values?;
+    constructor();
+    render(xmlStream: any, model?: any[]): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    static RELATIONSHIPS_ATTRIBUTES: {
+        xmlns: string;
+    };
+}
+export { RelationshipsXform };

package/dist/browser/modules/excel/xlsx/xform/core/relationships-xform.js

@@ -0,0 +1,62 @@
+import { XmlStream } from "../../../utils/xml-stream.js";
+import { BaseXform } from "../base-xform.js";
+import { RelationshipXform } from "./relationship-xform.js";
+class RelationshipsXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            Relationship: new RelationshipXform()
+        };
+    }
+    render(xmlStream, model) {
+        const renderModel = model || this._values;
+        xmlStream.openXml(XmlStream.StdDocAttributes);
+        xmlStream.openNode("Relationships", RelationshipsXform.RELATIONSHIPS_ATTRIBUTES);
+        renderModel.forEach(relationship => {
+            this.map.Relationship.render(xmlStream, relationship);
+        });
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case "Relationships":
+                this.model = [];
+                return true;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                    return true;
+                }
+                throw new Error(`Unexpected xml node in parseOpen: ${JSON.stringify(node)}`);
+        }
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.model.push(this.parser.model);
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case "Relationships":
+                return false;
+            default:
+                throw new Error(`Unexpected xml node in parseClose: ${name}`);
+        }
+    }
+}
+RelationshipsXform.RELATIONSHIPS_ATTRIBUTES = {
+    xmlns: "http://schemas.openxmlformats.org/package/2006/relationships"
+};
+export { RelationshipsXform };

package/dist/browser/modules/excel/xlsx/xform/drawing/base-cell-anchor-xform.d.ts

@@ -0,0 +1,13 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+declare abstract class BaseCellAnchorXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    model: any;
+    abstract get tag(): string;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    reconcilePicture(model: any, options: any): any;
+}
+export { BaseCellAnchorXform };

package/dist/browser/modules/excel/xlsx/xform/drawing/base-cell-anchor-xform.js

@@ -0,0 +1,44 @@
+import { BaseXform } from "../base-xform.js";
+class BaseCellAnchorXform extends BaseXform {
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case this.tag:
+                this.reset();
+                this.model = {
+                    range: {
+                        editAs: node.attributes.editAs || "oneCell"
+                    }
+                };
+                break;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                }
+                break;
+        }
+        return true;
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    reconcilePicture(model, options) {
+        if (model && model.rId) {
+            const rel = options.rels[model.rId];
+            const match = rel.Target.match(/.*\/media\/(.+[.][a-zA-Z]{3,4})/);
+            if (match) {
+                const name = match[1];
+                const mediaId = options.mediaIndex[name];
+                return options.media[mediaId];
+            }
+        }
+        return undefined;
+    }
+}
+export { BaseCellAnchorXform };

package/dist/browser/modules/excel/xlsx/xform/drawing/blip-fill-xform.d.ts

@@ -0,0 +1,16 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { BlipXform } from "@excel/xlsx/xform/drawing/blip-xform";
+declare class BlipFillXform extends BaseXform {
+    map: {
+        [key: string]: BlipXform;
+    };
+    parser: any;
+    model: any;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+}
+export { BlipFillXform };

package/dist/browser/modules/excel/xlsx/xform/drawing/blip-fill-xform.js

@@ -0,0 +1,57 @@
+import { BaseXform } from "../base-xform.js";
+import { BlipXform } from "./blip-xform.js";
+class BlipFillXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            "a:blip": new BlipXform()
+        };
+    }
+    get tag() {
+        return "xdr:blipFill";
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag);
+        this.map["a:blip"].render(xmlStream, model);
+        // TODO: options for this + parsing
+        xmlStream.openNode("a:stretch");
+        xmlStream.leafNode("a:fillRect");
+        xmlStream.closeNode();
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case this.tag:
+                this.reset();
+                break;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                }
+                break;
+        }
+        return true;
+    }
+    parseText() { }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                this.model = this.map["a:blip"].model;
+                return false;
+            default:
+                return true;
+        }
+    }
+}
+export { BlipFillXform };

package/dist/browser/modules/excel/xlsx/xform/drawing/blip-xform.d.ts

@@ -0,0 +1,14 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface BlipModel {
+    rId: string;
+}
+declare class BlipXform extends BaseXform {
+    model: BlipModel;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: BlipModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+}
+export { BlipXform };