clarity-js 0.6.23

package/src/layout/dom.ts

@@ -0,0 +1,442 @@
+import { Privacy } from "@clarity-types/core";
+import { Code, Setting, Severity } from "@clarity-types/data";
+import { Constant, NodeChange, NodeInfo, NodeValue, Source } from "@clarity-types/layout";
+import config from "@src/core/config";
+import { time } from "@src/core/time";
+import * as internal from "@src/diagnostic/internal";
+import * as extract from "@src/layout/extract";
+import * as region from "@src/layout/region";
+import selector from "@src/layout/selector";
+
+let index: number = 1;
+
+// Reference: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/Input#%3Cinput%3E_types
+const DISALLOWED_TYPES = ["password", "hidden", "email", "tel"];
+const DISALLOWED_NAMES = ["addr", "cell", "code", "dob", "email", "mob", "name", "phone", "secret", "social", "ssn", "tel", "zip", "pass"];
+const DISALLOWED_MATCH = ["address", "password", "contact"];
+
+let nodes: Node[] = [];
+let values: NodeValue[] = [];
+let changes: NodeChange[][] = [];
+let updateMap: number[] = [];
+let selectorMap: number[] = [];
+
+// The WeakMap object is a collection of key/value pairs in which the keys are weakly referenced
+let idMap: WeakMap<Node, number> = null; // Maps node => id.
+let iframeMap: WeakMap<Document, HTMLIFrameElement> = null; // Maps iframe's contentDocument => parent iframe element
+let privacyMap: WeakMap<Node, Privacy> = null; // Maps node => Privacy (enum)
+
+let urlMap: { [url: string]: number } = {};
+
+export function start(): void {
+    reset();
+    parse(document);
+}
+
+export function stop(): void {
+    reset();
+}
+
+function reset(): void {
+    index = 1;
+    nodes = [];
+    values = [];
+    updateMap = [];
+    changes = [];
+    selectorMap = [];
+    urlMap = {};
+    idMap = new WeakMap();
+    iframeMap = new WeakMap();
+    privacyMap = new WeakMap();
+    if (Constant.DevHook in window) { window[Constant.DevHook] = { get, getNode, history }; }
+}
+
+// We parse new root nodes for any regions or masked nodes in the beginning (document) and
+// later whenever there are new additions or modifications to DOM (mutations)
+export function parse(root: ParentNode): void {
+    // Wrap selectors in a try / catch block.
+    // It's possible for script to receive invalid selectors, e.g. "'#id'" with extra quotes, and cause the code below to fail
+    try {
+        // Since mutations may happen on leaf nodes too, e.g. text nodes, which may not support all selector APIs.
+        // We ensure that the root note supports querySelectorAll API before executing the code below to identify new regions.
+        if ("querySelectorAll" in root) {
+            extract.regions(root, config.regions);
+            extract.metrics(root, config.metrics);
+            config.mask.forEach(x => root.querySelectorAll(x).forEach(e => privacyMap.set(e, Privacy.TextImage))); // Masked Elements
+            config.unmask.forEach(x => root.querySelectorAll(x).forEach(e => privacyMap.set(e, Privacy.None))); // Unmasked Elements
+        }
+    } catch (e) { internal.log(Code.Selector, Severity.Warning, e ? e.name : null); }
+}
+
+export function getId(node: Node, autogen: boolean = false): number {
+    if (node === null) { return null; }
+    let id = idMap.get(node);
+    if (!id && autogen) {
+        id = index++;
+        idMap.set(node, id);
+    }
+
+    return id ? id : null;
+}
+
+export function add(node: Node, parent: Node, data: NodeInfo, source: Source): void {
+    let id = getId(node, true);
+    let parentId = parent ? getId(parent) : null;
+    let previousId = getPreviousId(node);
+    let privacy = config.content ? Privacy.Sensitive : Privacy.Text;
+    let parentValue = null;
+    let parentTag = Constant.Empty;
+    let regionId = region.exists(node) ? id : null;
+
+    if (parentId >= 0 && values[parentId]) {
+        parentValue = values[parentId];
+        parentTag = parentValue.data.tag;
+        parentValue.children.push(id);
+        regionId = regionId === null ? parentValue.region : regionId;
+        privacy = parentValue.metadata.privacy;
+    }
+
+    // Check to see if this particular node should be masked or not
+    privacy = getPrivacy(node, data, parentTag, privacy);
+
+    // If there's an explicit region attribute set on the element, use it to mark a region on the page
+    if (data.attributes && Constant.RegionData in data.attributes) {
+        region.observe(node, data.attributes[Constant.RegionData]);
+        regionId = id;
+    }
+
+    nodes[id] = node;
+    values[id] = {
+        id,
+        parent: parentId,
+        previous: previousId,
+        children: [],
+        position: null,
+        data,
+        selector: Constant.Empty,
+        region: regionId,
+        metadata: { active: true, privacy, size: null }
+    };
+
+    updateSelector(values[id]);
+    size(values[id], parentValue);
+    metadata(data.tag, id, parentId);
+    track(id, source);
+}
+
+export function update(node: Node, parent: Node, data: NodeInfo, source: Source): void {
+    let id = getId(node);
+    let parentId = parent ? getId(parent) : null;
+    let previousId = getPreviousId(node);
+    let changed = false;
+    let parentChanged = false;
+
+    if (id in values) {
+        let value = values[id];
+        value.metadata.active = true;
+
+        // Handle case where internal ordering may have changed
+        if (value.previous !== previousId) {
+            changed = true;
+            value.previous = previousId;
+        }
+
+        // Handle case where parent might have been updated
+        if (value.parent !== parentId) {
+            changed = true;
+            let oldParentId = value.parent;
+            value.parent = parentId;
+            // Move this node to the right location under new parent
+            if (parentId !== null && parentId >= 0) {
+                let childIndex = previousId === null ? 0 : values[parentId].children.indexOf(previousId) + 1;
+                values[parentId].children.splice(childIndex, 0, id);
+                // Update region after the move
+                value.region = region.exists(node) ? id : values[parentId].region;
+            } else {
+                // Mark this element as deleted if the parent has been updated to null
+                remove(id, source);
+            }
+
+            // Remove reference to this node from the old parent
+            if (oldParentId !== null && oldParentId >= 0) {
+                let nodeIndex = values[oldParentId].children.indexOf(id);
+                if (nodeIndex >= 0) {
+                    values[oldParentId].children.splice(nodeIndex, 1);
+                }
+            }
+            parentChanged = true;
+        }
+
+        // Update data
+        for (let key in data) {
+            if (diff(value["data"], data, key)) {
+                changed = true;
+                value["data"][key] = data[key];
+            }
+        }
+
+        // Update selector
+        updateSelector(value);
+        metadata(data.tag, id, parentId);
+        track(id, source, changed, parentChanged);
+    }
+}
+
+export function sameorigin(node: Node): boolean {
+    let output = false;
+    if (node.nodeType === Node.ELEMENT_NODE && (node as HTMLElement).tagName === Constant.IFrameTag) {
+        let frame = node as HTMLIFrameElement;
+        // To determine if the iframe is same-origin or not, we try accessing it's contentDocument.
+        // If the browser throws an exception, we assume it's cross-origin and move on.
+        // However, if we do a get a valid document object back, we assume the contents are accessible and iframe is same-origin.
+        try {
+            let doc = frame.contentDocument;
+            if (doc) {
+                iframeMap.set(frame.contentDocument, frame);
+                output = true;
+            }
+        } catch { /* do nothing */ }
+    }
+    return output;
+}
+
+export function iframe(node: Node): HTMLIFrameElement {
+    let doc = node.nodeType === Node.DOCUMENT_NODE ? node as Document : null;
+    return doc && iframeMap.has(doc) ? iframeMap.get(doc) : null;
+}
+
+function getPrivacy(node: Node, data: NodeInfo, parentTag: string, privacy: Privacy): Privacy {
+    let attributes = data.attributes;
+    let tag = data.tag.toUpperCase();
+
+    // If this node was explicitly configured to contain sensitive content, use that information and return the value
+    if (privacyMap.has(node)) { return privacyMap.get(node); }
+
+    // Do not proceed if attributes are missing for the node
+    if (attributes === null || attributes === undefined) { return privacy; }
+
+    // Look up for sensitive fields
+    if (Constant.Class in attributes && privacy === Privacy.Sensitive) {
+        for (let match of DISALLOWED_MATCH) {
+            if (attributes[Constant.Class].indexOf(match) >= 0) {
+                privacy = Privacy.Text;
+                break;
+            }
+        }
+    }
+
+    // Check for disallowed list of fields (e.g. address, phone, etc.) only if the input node is not already masked
+    if (tag === Constant.InputTag) {
+        if (privacy === Privacy.None) {
+            let field: string = Constant.Empty;
+            // Be aggressive in looking up any attribute (id, class, name, etc.) for disallowed names
+            for (const attribute of Object.keys(attributes)) { field += attributes[attribute].toLowerCase(); }
+            for (let name of DISALLOWED_NAMES) {
+                if (field.indexOf(name) >= 0) {
+                    privacy = Privacy.Text;
+                    break;
+                }
+            }
+        } else if (privacy === Privacy.Sensitive) {
+            // Mask all input fields with an exception of type=submit; since they do not accept user input
+            privacy = attributes && attributes[Constant.Type] === Constant.Submit ? Privacy.None : Privacy.Text;
+        }
+    }
+
+    // Check for disallowed list of types (e.g. password, email, etc.) and set the masked property appropriately
+    if (Constant.Type in attributes && DISALLOWED_TYPES.indexOf(attributes[Constant.Type]) >= 0) { privacy = Privacy.Text; }
+
+    // Following two conditions supersede any of the above. If there are explicit instructions to mask / unmask a field, we honor that.
+    if (Constant.MaskData in attributes) { privacy = Privacy.TextImage; }
+    if (Constant.UnmaskData in attributes) { privacy = Privacy.None; }
+
+    // If it's a text node belonging to a STYLE or TITLE tag; then reset the privacy setting to ensure we capture the content
+    let cTag = tag === Constant.TextTag ? parentTag : tag;
+    if (cTag === Constant.StyleTag || cTag === Constant.TitleTag) { privacy = Privacy.None; }
+
+    return privacy;
+}
+
+function diff(a: NodeInfo, b: NodeInfo, field: string): boolean {
+    if (typeof a[field] === "object" && typeof b[field] === "object") {
+        for (let key in a[field]) { if (a[field][key] !== b[field][key]) { return true; } }
+        for (let key in b[field]) { if (b[field][key] !== a[field][key]) { return true; } }
+        return false;
+    }
+    return a[field] !== b[field];
+}
+
+function position(parent: NodeValue, child: NodeValue): number {
+    let tag = child.data.tag;
+    let hasClassName = child.data.attributes && !(Constant.Class in child.data.attributes);
+    // Find relative position of the element to generate :nth-of-type selector
+    // We restrict relative positioning to two cases:
+    //   a) For specific whitelist of tags
+    //   b) And, for remaining tags, only if they don't have a valid class name
+    if (parent && (["DIV", "TR", "P", "LI", "UL", "A", "BUTTON"].indexOf(tag) >= 0 || hasClassName)) {
+        child.position = 1;
+        let idx = parent ? parent.children.indexOf(child.id) : -1;
+        while (idx-- > 0) {
+            let sibling = values[parent.children[idx]];
+            if (child.data.tag === sibling.data.tag) {
+                child.position = sibling.position + 1;
+                break;
+            }
+        }
+    }
+    return child.position;
+}
+
+function updateSelector(value: NodeValue): void {
+    let parent = value.parent && value.parent in values ? values[value.parent] : null;
+    let prefix = parent ? `${parent.selector}>` : null;
+    let ex = value.selector;
+    let current = selector(value.data.tag, prefix, value.data.attributes, position(parent, value));
+    if (current !== ex && selectorMap.indexOf(value.id) === -1) { selectorMap.push(value.id); }
+    value.selector = current;
+}
+
+export function getNode(id: number): Node {
+    if (id in nodes) {
+        return nodes[id];
+    }
+    return null;
+}
+
+export function getMatch(url: string): Node {
+    if (url in urlMap) {
+        return getNode(urlMap[url]);
+    }
+    return null;
+}
+
+export function getValue(id: number): NodeValue {
+    if (id in values) {
+        return values[id];
+    }
+    return null;
+}
+
+export function get(node: Node): NodeValue {
+    let id = getId(node);
+    return id in values ? values[id] : null;
+}
+
+export function has(node: Node): boolean {
+    return getId(node) in nodes;
+}
+
+export function updates(): NodeValue[] {
+    let output = [];
+    for (let id of updateMap) {
+        if (id in values) {
+            let v = values[id];
+            let p = v.parent;
+            v.data.path = p === null || updateMap.indexOf(p) >= 0 || v.selector.length === 0 ? null : values[p].selector;
+            output.push(values[id]);
+        }
+    }
+    updateMap = [];
+    return output;
+}
+
+function remove(id: number, source: Source): void {
+    if (id in values) {
+        let value = values[id];
+        value.metadata.active = false;
+        value.parent = null;
+        track(id, source);
+    }
+}
+
+function size(value: NodeValue, parent: NodeValue): void {
+    let data = value.data;
+    let tag = data.tag;
+
+    // If this element is a text node, is masked, and longer than configured length, then track box model for the parent element
+    let isLongText = tag === Constant.TextTag && data.value && data.value.length > Setting.ResizeObserverThreshold;
+    let isMasked = value.metadata.privacy === Privacy.Text || value.metadata.privacy === Privacy.TextImage;
+    if (isLongText && isMasked && parent && parent.metadata.size === null) { parent.metadata.size = []; }
+
+    // If this element is a image node, and is masked, then track box model for the current element
+    if (data.tag === Constant.ImageTag && value.metadata.privacy === Privacy.TextImage) { value.metadata.size = []; }
+}
+
+function metadata(tag: string, id: number, parentId: number): void {
+    if (id !== null && parentId !== null) {
+        let value = values[id];
+        let attributes = "attributes" in value.data ? value.data.attributes : {};
+        switch (tag) {
+            case "VIDEO":
+            case "AUDIO":
+            case "LINK":
+                // Track mapping between URL and corresponding nodes
+                if (Constant.Href in attributes && attributes[Constant.Href].length > 0) {
+                    urlMap[getFullUrl(attributes[Constant.Href])] = id;
+                }
+                if (Constant.Src in attributes && attributes[Constant.Src].length > 0) {
+                    if (attributes[Constant.Src].indexOf(Constant.DataPrefix) !== 0) {
+                        urlMap[getFullUrl(attributes[Constant.Src])] = id;
+                    }
+                }
+                if (Constant.Srcset in attributes && attributes[Constant.Srcset].length > 0) {
+                    let srcset = attributes[Constant.Srcset];
+                    let urls = srcset.split(",");
+                    for (let u of urls) {
+                        let parts = u.trim().split(" ");
+                        if (parts.length === 2 && parts[0].length > 0) {
+                            urlMap[getFullUrl(parts[0])] = id;
+                        }
+                    }
+                }
+                break;
+        }
+    }
+}
+
+function getFullUrl(relative: string): string {
+    let a = document.createElement("a");
+    a.href = relative;
+    return a.href;
+}
+
+function getPreviousId(node: Node): number {
+    let id = null;
+
+    // Some nodes may not have an ID by design since Clarity skips over tags like SCRIPT, NOSCRIPT, META, COMMENTS, etc..
+    // In that case, we keep going back and check for their sibling until we find a sibling with ID or no more sibling nodes are left.
+    while (id === null && node.previousSibling) {
+        id = getId(node.previousSibling);
+        node = node.previousSibling;
+    }
+    return id;
+}
+
+function copy(input: NodeValue[]): NodeValue[] {
+    return JSON.parse(JSON.stringify(input));
+}
+
+function track(id: number, source: Source, changed: boolean = true, parentChanged: boolean = false): void {
+    // Keep track of the order in which mutations happened, they may not be sequential
+    // Edge case: If an element is added later on, and pre-discovered element is moved as a child.
+    // In that case, we need to reorder the pre-discovered element in the update list to keep visualization consistent.
+    let uIndex = updateMap.indexOf(id);
+    if (uIndex >= 0 && source === Source.ChildListAdd && parentChanged) {
+        updateMap.splice(uIndex, 1);
+        updateMap.push(id);
+    } else if (uIndex === -1 && changed) { updateMap.push(id); }
+
+    if (Constant.DevHook in window) {
+        let value = copy([values[id]])[0];
+        let change = { time: time(), source, value };
+        if (!(id in changes)) { changes[id] = []; }
+        changes[id].push(change);
+    }
+}
+
+function history(id: number): NodeChange[] {
+    if (id in changes) {
+        return changes[id];
+    }
+    return [];
+}

package/src/layout/encode.ts

@@ -0,0 +1,111 @@
+import { Privacy, Task, Timer } from "@clarity-types/core";
+import { Event, Token } from "@clarity-types/data";
+import { Constant, NodeInfo, NodeValue } from "@clarity-types/layout";
+import config from "@src/core/config";
+import scrub from "@src/core/scrub";
+import * as task from "@src/core/task";
+import { time } from "@src/core/time";
+import tokenize from "@src/data/token";
+import * as baseline from "@src/data/baseline";
+import { queue } from "@src/data/upload";
+import * as box from "./box";
+import * as doc from "./document";
+import * as dom from "./dom";
+import * as region from "./region";
+
+export default async function (type: Event, timer: Timer = null, ts: number = null): Promise<void> {
+    let eventTime = ts || time()
+    let tokens: Token[] = [eventTime, type];
+    switch (type) {
+        case Event.Document:
+            let d = doc.data;
+            tokens.push(d.width);
+            tokens.push(d.height);
+            baseline.track(type, d.width, d.height);
+            queue(tokens);
+            break;
+        case Event.Region:
+            for (let r of region.state) {
+                tokens = [r.time, Event.Region];
+                tokens.push(r.data.id);
+                tokens.push(r.data.state);
+                tokens.push(r.data.name);
+                queue(tokens);
+            }
+            region.reset();
+            break;
+        case Event.Box:
+            let b = box.data;
+            for (let entry of b) {
+                tokens.push(entry.id);
+                tokens.push(entry.width);
+                tokens.push(entry.height);
+            }
+            box.reset();
+            queue(tokens);
+            break;
+        case Event.Discover:
+        case Event.Mutation:
+            // Check if we are operating within the context of the current page
+            if (task.state(timer) === Task.Stop) { break; }
+            let values = dom.updates();
+            // Only encode and queue DOM updates if we have valid updates to report back
+            if (values.length > 0) {
+                for (let value of values) {
+                    let state = task.state(timer);
+                    if (state === Task.Wait) { state = await task.suspend(timer); }
+                    if (state === Task.Stop) { break; }
+                    let data: NodeInfo = value.data;
+                    let active = value.metadata.active;
+                    let privacy = value.metadata.privacy;
+                    let mangle = shouldMangle(value);
+                    let keys = active ? ["tag", "path", "attributes", "value"] : ["tag"];
+                    box.compute(value.id);
+                    for (let key of keys) {
+                        if (data[key]) {
+                            switch (key) {
+                                case "tag":
+                                    let size = value.metadata.size;
+                                    let factor = mangle ? -1 : 1;
+                                    tokens.push(value.id * factor);
+                                    if (value.parent && active) { tokens.push(value.parent); }
+                                    if (value.previous && active) { tokens.push(value.previous); }
+                                    tokens.push(value.position ? `${data[key]}~${value.position}` : data[key]);
+                                    if (size && size.length === 2) { tokens.push(`${Constant.Box}${str(size[0])}.${str(size[1])}`); }
+                                    break;
+                                case "path":
+                                    tokens.push(`${value.data.path}>`);
+                                    break;
+                                case "attributes":
+                                    for (let attr in data[key]) {
+                                        if (data[key][attr] !== undefined) {
+                                            tokens.push(attribute(attr, data[key][attr], privacy));
+                                        }
+                                    }
+                                    break;
+                                case "value":
+                                    tokens.push(scrub(data[key], data.tag, privacy, mangle));
+                                    break;
+                            }
+                        }
+                    }
+                }
+                if (type === Event.Mutation) { baseline.activity(eventTime); }
+                queue(tokenize(tokens), !config.lean);
+            }
+            break;
+    }
+}
+
+function shouldMangle(value: NodeValue): boolean {
+    let privacy = value.metadata.privacy;
+    return value.data.tag === Constant.TextTag && !(privacy === Privacy.None || privacy === Privacy.Sensitive);
+}
+
+function str(input: number): string {
+    return input.toString(36);
+}
+
+function attribute(key: string, value: string, privacy: Privacy): string {
+    return `${key}=${scrub(value, key, privacy)}`;
+}

package/src/layout/extract.ts

@@ -0,0 +1,75 @@
+import { Extract, Metric, Region, RegionFilter } from "@clarity-types/core";
+import { Constant } from "@clarity-types/data";
+import * as metric from "@src/data/metric";
+import * as region from "@src/layout/region";
+
+const formatRegex = /1/g;
+const digitsRegex = /[^0-9\.]/g;
+const digitsWithCommaRegex = /[^0-9\.,]/g;
+const regexCache: {[key: string]: RegExp} = {};
+
+export function regions(root: ParentNode, value: Region[]): void {
+    for (let v of value) {
+        const [regionId, selector, filter, match] = v;
+        let valid = true;
+        switch (filter) {
+            case RegionFilter.Url: valid = match && !!top.location.href.match(regex(match)); break;
+            case RegionFilter.Javascript: valid = match && !!evaluate(match); break;
+        }
+        if (valid) { root.querySelectorAll(selector).forEach(e => region.observe(e, regionId.toString())); }
+    }
+}
+
+export function metrics(root: ParentNode, value: Metric[]): void {
+    for (let v of value) {
+        const [metricId, source, match, scale] = v;
+        if (match) {
+            switch (source) {
+                case Extract.Text:  root.querySelectorAll(match).forEach(e => { metric.max(metricId, num((e as HTMLElement).innerText, scale)); }); break;
+                case Extract.Attribute: root.querySelectorAll(`[${match}]`).forEach(e => { metric.max(metricId, num(e.getAttribute(match), scale, false)); }); break;
+                case Extract.Javascript: metric.max(metricId, evaluate(match, Constant.Number) as number); break;
+            }
+        }
+    }
+}
+
+function regex(match: string): RegExp {
+    regexCache[match] = match in regexCache ? regexCache[match] : new RegExp(match);
+    return regexCache[match];
+}
+
+// The function below takes in a variable name in following format: "a.b.c" and safely evaluates its value in javascript context
+// For instance, for a.b.c, it will first check window["a"]. If it exists, it will recursively look at: window["a"]["b"] and finally,
+// return the value for window["a"]["b"]["c"].
+function evaluate(variable: string, type: string = null, base: Object = window): any {
+    let parts = variable.split(Constant.Dot);
+    let first = parts.shift();
+    if (base && base[first]) {
+        if (parts.length > 0) { return evaluate(parts.join(Constant.Dot), type, base[first]); } 
+        let output = type === null || type === typeof base[first] ? base[first] : null;
+        return output;
+    }
+    return null;
+}
+
+function num(text: string, scale: number, localize: boolean = true): number {
+    try {
+        scale = scale || 1; 
+        // Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
+        let lang = document.documentElement.lang;
+        if (Intl && Intl.NumberFormat && lang && localize) {
+            text = text.replace(digitsWithCommaRegex, Constant.Empty);
+            // Infer current group and decimal separator from current locale
+            let group = Intl.NumberFormat(lang).format(11111).replace(formatRegex, Constant.Empty);
+            let decimal = Intl.NumberFormat(lang).format(1.1).replace(formatRegex, Constant.Empty);
+            
+            // Parse number using inferred group and decimal separators
+            return Math.round(parseFloat(text
+                .replace(new RegExp('\\' + group, 'g'), Constant.Empty)
+                .replace(new RegExp('\\' + decimal), Constant.Dot)
+            ) * scale);
+        }
+        // Fallback to en locale
+        return Math.round(parseFloat(text.replace(digitsRegex, Constant.Empty)) * scale);
+    } catch { return null; }
+}

package/src/layout/index.ts

@@ -0,0 +1,25 @@
+import * as box from "@src/layout/box";
+import * as discover from "@src/layout/discover";
+import * as doc from "@src/layout/document";
+import * as dom from "@src/layout/dom";
+import * as mutation from "@src/layout/mutation";
+import * as region from "@src/layout/region";
+
+export function start(): void {
+    // The order below is important 
+    // and is determined by interdependencies of modules
+    doc.start();
+    region.start();
+    dom.start();
+    mutation.start();
+    discover.start();
+    box.start();
+}
+
+export function stop(): void {
+    region.stop();
+    dom.stop();
+    mutation.stop();
+    box.stop();
+    doc.end();
+}