@lexmata/micropdf 0.4.0

package/dist/pdf/object.js

@@ -0,0 +1,1045 @@
+/**
+ * PDF Object Model
+ *
+ * This implementation mirrors the Rust `pdf::object` module for 100% API compatibility.
+ */
+import { PdfObjectType } from '../types.js';
+/**
+ * Base class for all PDF objects
+ */
+export class PdfObject {
+    _refCount = 1;
+    _marked = false;
+    _parentNum = 0;
+    get isNull() {
+        return this.type === PdfObjectType.Null;
+    }
+    get isBool() {
+        return this.type === PdfObjectType.Bool;
+    }
+    get isInt() {
+        return this.type === PdfObjectType.Int;
+    }
+    get isReal() {
+        return this.type === PdfObjectType.Real;
+    }
+    get isNumber() {
+        return this.isInt || this.isReal;
+    }
+    get isString() {
+        return this.type === PdfObjectType.String;
+    }
+    get isName() {
+        return this.type === PdfObjectType.Name;
+    }
+    get isArray() {
+        return this.type === PdfObjectType.Array;
+    }
+    get isDict() {
+        return this.type === PdfObjectType.Dict;
+    }
+    get isStream() {
+        return this.type === PdfObjectType.Stream;
+    }
+    get isIndirect() {
+        return this.type === PdfObjectType.Indirect;
+    }
+    // ============================================================================
+    // Reference Counting
+    // ============================================================================
+    /**
+     * Increment reference count (keep object alive)
+     */
+    keep() {
+        this._refCount++;
+        return this;
+    }
+    /**
+     * Decrement reference count (may allow garbage collection)
+     */
+    drop() {
+        if (this._refCount > 0) {
+            this._refCount--;
+        }
+    }
+    /**
+     * Get current reference count
+     */
+    getRefs() {
+        return this._refCount;
+    }
+    // ============================================================================
+    // Object Marking (for traversal algorithms)
+    // ============================================================================
+    /**
+     * Check if object is marked
+     */
+    isMarked() {
+        return this._marked;
+    }
+    /**
+     * Mark this object
+     */
+    mark() {
+        this._marked = true;
+    }
+    /**
+     * Unmark this object
+     */
+    unmark() {
+        this._marked = false;
+    }
+    // ============================================================================
+    // Parent Tracking
+    // ============================================================================
+    /**
+     * Set parent object number (for indirect objects)
+     */
+    setParent(objNum) {
+        this._parentNum = objNum;
+    }
+    /**
+     * Get parent object number
+     */
+    getParentNum() {
+        return this._parentNum;
+    }
+    toBool() {
+        if (this instanceof PdfBool)
+            return this.value;
+        return false;
+    }
+    toInt() {
+        if (this instanceof PdfInt)
+            return this.value;
+        if (this instanceof PdfReal)
+            return Math.trunc(this.value);
+        return 0;
+    }
+    toReal() {
+        if (this instanceof PdfReal)
+            return this.value;
+        if (this instanceof PdfInt)
+            return this.value;
+        return 0;
+    }
+    toNumber() {
+        return this.toReal();
+    }
+    toString() {
+        if (this instanceof PdfString)
+            return this.value;
+        return '';
+    }
+    toName() {
+        if (this instanceof PdfName)
+            return this.value;
+        return '';
+    }
+    nameEquals(name) {
+        if (this instanceof PdfName)
+            return this.value === name;
+        return false;
+    }
+}
+/**
+ * PDF Null object
+ */
+class PdfNull extends PdfObject {
+    get type() {
+        return PdfObjectType.Null;
+    }
+    equals(other) {
+        return other instanceof PdfNull;
+    }
+}
+/**
+ * PDF Boolean object
+ */
+class PdfBool extends PdfObject {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    get type() {
+        return PdfObjectType.Bool;
+    }
+    equals(other) {
+        return other instanceof PdfBool && other.value === this.value;
+    }
+}
+/**
+ * PDF Integer object
+ */
+class PdfInt extends PdfObject {
+    value;
+    constructor(value) {
+        super();
+        this.value = Math.trunc(value);
+    }
+    get type() {
+        return PdfObjectType.Int;
+    }
+    equals(other) {
+        return other instanceof PdfInt && other.value === this.value;
+    }
+}
+/**
+ * PDF Real (floating point) object
+ */
+class PdfReal extends PdfObject {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    get type() {
+        return PdfObjectType.Real;
+    }
+    equals(other) {
+        return other instanceof PdfReal && other.value === this.value;
+    }
+}
+/**
+ * PDF String object
+ */
+class PdfString extends PdfObject {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    get type() {
+        return PdfObjectType.String;
+    }
+    equals(other) {
+        return other instanceof PdfString && other.value === this.value;
+    }
+}
+/**
+ * PDF Name object
+ */
+class PdfName extends PdfObject {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    get type() {
+        return PdfObjectType.Name;
+    }
+    equals(other) {
+        return other instanceof PdfName && other.value === this.value;
+    }
+}
+/**
+ * PDF Array object
+ */
+export class PdfArray extends PdfObject {
+    items;
+    dirty = false;
+    constructor(items = []) {
+        super();
+        this.items = [...items];
+    }
+    get type() {
+        return PdfObjectType.Array;
+    }
+    /**
+     * Get the number of elements in the array
+     */
+    get length() {
+        return this.items.length;
+    }
+    /**
+     * Get element at the specified index
+     */
+    get(index) {
+        return this.items[index];
+    }
+    /**
+     * Set element at the specified index (alias for put)
+     */
+    put(index, obj) {
+        if (index >= 0 && index < this.items.length) {
+            this.items[index] = obj;
+            this.dirty = true;
+        }
+    }
+    /**
+     * Push a PDF object to the end of the array
+     */
+    push(obj) {
+        this.items.push(obj);
+        this.dirty = true;
+    }
+    /**
+     * Push an integer value to the end of the array
+     */
+    pushInt(value) {
+        this.items.push(new PdfInt(value));
+        this.dirty = true;
+    }
+    /**
+     * Push a real (float) value to the end of the array
+     */
+    pushReal(value) {
+        this.items.push(new PdfReal(value));
+        this.dirty = true;
+    }
+    /**
+     * Push a boolean value to the end of the array
+     */
+    pushBool(value) {
+        this.items.push(new PdfBool(value));
+        this.dirty = true;
+    }
+    /**
+     * Push a name to the end of the array
+     */
+    pushName(value) {
+        this.items.push(new PdfName(value));
+        this.dirty = true;
+    }
+    /**
+     * Push a string to the end of the array
+     */
+    pushString(value) {
+        this.items.push(new PdfString(value));
+        this.dirty = true;
+    }
+    /**
+     * Insert element at the specified index
+     */
+    insert(index, obj) {
+        if (index >= 0 && index <= this.items.length) {
+            this.items.splice(index, 0, obj);
+            this.dirty = true;
+        }
+    }
+    /**
+     * Delete element at the specified index
+     */
+    delete(index) {
+        if (index >= 0 && index < this.items.length) {
+            this.items.splice(index, 1);
+            this.dirty = true;
+        }
+    }
+    /**
+     * Convert to a JavaScript array
+     */
+    toArray() {
+        return [...this.items];
+    }
+    /**
+     * Check if this array has been modified
+     */
+    isDirty() {
+        return this.dirty;
+    }
+    /**
+     * Mark this array as dirty (modified)
+     */
+    markDirty() {
+        this.dirty = true;
+    }
+    /**
+     * Mark this array as clean (not modified)
+     */
+    markClean() {
+        this.dirty = false;
+    }
+    /**
+     * Create a shallow copy of this array
+     */
+    copy() {
+        return new PdfArray([...this.items]);
+    }
+    /**
+     * Create a deep copy of this array
+     */
+    deepCopy() {
+        const copied = this.items.map((item) => {
+            if (item instanceof PdfArray)
+                return item.deepCopy();
+            if (item instanceof PdfDict)
+                return item.deepCopy();
+            if (item instanceof PdfStream)
+                return item.deepCopy();
+            return item; // Primitive types are immutable
+        });
+        return new PdfArray(copied);
+    }
+    [Symbol.iterator]() {
+        return this.items[Symbol.iterator]();
+    }
+    equals(other) {
+        if (!(other instanceof PdfArray))
+            return false;
+        if (other.length !== this.length)
+            return false;
+        for (let i = 0; i < this.length; i++) {
+            if (!this.items[i].equals(other.items[i]))
+                return false;
+        }
+        return true;
+    }
+}
+/**
+ * PDF Dictionary object
+ */
+export class PdfDict extends PdfObject {
+    entries;
+    dirty = false;
+    constructor(entries = {}) {
+        super();
+        this.entries = new Map(Object.entries(entries));
+    }
+    get type() {
+        return PdfObjectType.Dict;
+    }
+    /**
+     * Get the number of entries in the dictionary
+     */
+    get length() {
+        return this.entries.size;
+    }
+    /**
+     * Get value for a key
+     */
+    get(key) {
+        return this.entries.get(key);
+    }
+    /**
+     * Put a PDF object value for a key
+     */
+    put(key, value) {
+        this.entries.set(key, value);
+        this.dirty = true;
+    }
+    /**
+     * Put an integer value for a key
+     */
+    putInt(key, value) {
+        this.entries.set(key, new PdfInt(value));
+        this.dirty = true;
+    }
+    /**
+     * Put a real (float) value for a key
+     */
+    putReal(key, value) {
+        this.entries.set(key, new PdfReal(value));
+        this.dirty = true;
+    }
+    /**
+     * Put a boolean value for a key
+     */
+    putBool(key, value) {
+        this.entries.set(key, new PdfBool(value));
+        this.dirty = true;
+    }
+    /**
+     * Put a name for a key
+     */
+    putName(key, value) {
+        this.entries.set(key, new PdfName(value));
+        this.dirty = true;
+    }
+    /**
+     * Put a string for a key
+     */
+    putString(key, value) {
+        this.entries.set(key, new PdfString(value));
+        this.dirty = true;
+    }
+    /**
+     * Delete a key from the dictionary
+     */
+    del(key) {
+        if (this.entries.delete(key)) {
+            this.dirty = true;
+        }
+    }
+    /**
+     * Check if a key exists in the dictionary
+     */
+    has(key) {
+        return this.entries.has(key);
+    }
+    /**
+     * Get all keys in the dictionary
+     */
+    keys() {
+        return [...this.entries.keys()];
+    }
+    /**
+     * Get all values in the dictionary
+     */
+    values() {
+        return [...this.entries.values()];
+    }
+    /**
+     * Get all entries as [key, value] pairs
+     */
+    getEntries() {
+        return [...this.entries.entries()];
+    }
+    *[Symbol.iterator]() {
+        for (const [key, value] of this.entries) {
+            yield [key, value];
+        }
+    }
+    // ============================================================================
+    // Typed getters with defaults
+    // ============================================================================
+    /**
+     * Get name value for a key
+     */
+    getName(key) {
+        return this.get(key)?.toName() ?? '';
+    }
+    /**
+     * Get string value for a key
+     */
+    getString(key) {
+        return this.get(key)?.toString() ?? '';
+    }
+    /**
+     * Get integer value for a key
+     */
+    getInt(key, defaultValue = 0) {
+        const obj = this.get(key);
+        return obj ? obj.toInt() : defaultValue;
+    }
+    /**
+     * Get real (float) value for a key
+     */
+    getReal(key, defaultValue = 0) {
+        const obj = this.get(key);
+        return obj ? obj.toReal() : defaultValue;
+    }
+    /**
+     * Get boolean value for a key
+     */
+    getBool(key, defaultValue = false) {
+        const obj = this.get(key);
+        return obj ? obj.toBool() : defaultValue;
+    }
+    /**
+     * Get array for a key
+     */
+    getArray(key) {
+        const obj = this.get(key);
+        return obj instanceof PdfArray ? obj : undefined;
+    }
+    /**
+     * Get dictionary for a key
+     */
+    getDict(key) {
+        const obj = this.get(key);
+        return obj instanceof PdfDict ? obj : undefined;
+    }
+    /**
+     * Get stream for a key
+     */
+    getStream(key) {
+        const obj = this.get(key);
+        return obj instanceof PdfStream ? obj : undefined;
+    }
+    // ============================================================================
+    // Dirty tracking
+    // ============================================================================
+    /**
+     * Check if this dictionary has been modified
+     */
+    isDirty() {
+        return this.dirty;
+    }
+    /**
+     * Mark this dictionary as dirty (modified)
+     */
+    markDirty() {
+        this.dirty = true;
+    }
+    /**
+     * Mark this dictionary as clean (not modified)
+     */
+    markClean() {
+        this.dirty = false;
+    }
+    // ============================================================================
+    // Copying
+    // ============================================================================
+    /**
+     * Create a shallow copy of this dictionary
+     */
+    copy() {
+        const entries = {};
+        for (const [key, value] of this.entries) {
+            entries[key] = value;
+        }
+        return new PdfDict(entries);
+    }
+    /**
+     * Create a deep copy of this dictionary
+     */
+    deepCopy() {
+        const entries = {};
+        for (const [key, value] of this.entries) {
+            if (value instanceof PdfArray) {
+                entries[key] = value.deepCopy();
+            }
+            else if (value instanceof PdfDict) {
+                entries[key] = value.deepCopy();
+            }
+            else if (value instanceof PdfStream) {
+                entries[key] = value.deepCopy();
+            }
+            else {
+                entries[key] = value; // Primitive types are immutable
+            }
+        }
+        return new PdfDict(entries);
+    }
+    equals(other) {
+        if (!(other instanceof PdfDict))
+            return false;
+        if (other.length !== this.length)
+            return false;
+        for (const [key, value] of this.entries) {
+            const otherValue = other.get(key);
+            if (!otherValue || !value.equals(otherValue))
+                return false;
+        }
+        return true;
+    }
+}
+/**
+ * PDF Stream object
+ */
+export class PdfStream extends PdfObject {
+    dict;
+    _data;
+    constructor(dict, data = new Uint8Array(0)) {
+        super();
+        this.dict = dict;
+        this._data = data;
+    }
+    get type() {
+        return PdfObjectType.Stream;
+    }
+    /**
+     * Get the stream data
+     */
+    getData() {
+        return this._data;
+    }
+    /**
+     * Set the stream data
+     */
+    setData(data) {
+        this._data = data;
+        this.dict.markDirty();
+    }
+    /**
+     * Get the stream dictionary
+     */
+    getDict() {
+        return this.dict;
+    }
+    /**
+     * Create a deep copy of this stream
+     */
+    deepCopy() {
+        const dictCopy = this.dict.deepCopy();
+        const dataCopy = new Uint8Array(this._data);
+        return new PdfStream(dictCopy, dataCopy);
+    }
+    equals(other) {
+        if (!(other instanceof PdfStream))
+            return false;
+        if (!this.dict.equals(other.dict))
+            return false;
+        if (this._data.length !== other._data.length)
+            return false;
+        for (let i = 0; i < this._data.length; i++) {
+            if (this._data[i] !== other._data[i])
+                return false;
+        }
+        return true;
+    }
+}
+/**
+ * PDF Indirect Reference object
+ */
+export class PdfIndirectRef extends PdfObject {
+    objNum;
+    genNum;
+    constructor(objNum, genNum = 0) {
+        super();
+        this.objNum = objNum;
+        this.genNum = genNum;
+    }
+    get type() {
+        return PdfObjectType.Indirect;
+    }
+    equals(other) {
+        return (other instanceof PdfIndirectRef &&
+            other.objNum === this.objNum &&
+            other.genNum === this.genNum);
+    }
+}
+// ============================================================================
+// Factory Functions
+// ============================================================================
+const NULL_SINGLETON = new PdfNull();
+/**
+ * Create a null PDF object
+ */
+export function pdfNull() {
+    return NULL_SINGLETON;
+}
+/**
+ * Create a boolean PDF object
+ */
+export function pdfBool(value) {
+    return new PdfBool(value);
+}
+/**
+ * Create an integer PDF object
+ */
+export function pdfInt(value) {
+    return new PdfInt(value);
+}
+/**
+ * Create a real PDF object
+ */
+export function pdfReal(value) {
+    return new PdfReal(value);
+}
+/**
+ * Create a string PDF object
+ */
+export function pdfString(value) {
+    return new PdfString(value);
+}
+/**
+ * Create a name PDF object
+ */
+export function pdfName(value) {
+    return new PdfName(value);
+}
+/**
+ * Create an array PDF object
+ */
+export function pdfArray(items = []) {
+    return new PdfArray(items);
+}
+/**
+ * Create a dictionary PDF object
+ */
+export function pdfDict(entries = {}) {
+    return new PdfDict(entries);
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Compare two PDF objects for equality
+ */
+export function pdfObjectCompare(a, b) {
+    return a.equals(b);
+}
+/**
+ * Check if a PDF name equals a string value
+ */
+export function pdfNameEquals(obj, name) {
+    return obj.nameEquals(name);
+}
+/**
+ * Create a deep copy of a PDF object
+ */
+export function pdfDeepCopy(obj) {
+    if (obj instanceof PdfArray)
+        return obj.deepCopy();
+    if (obj instanceof PdfDict)
+        return obj.deepCopy();
+    if (obj instanceof PdfStream)
+        return obj.deepCopy();
+    // Primitive types are immutable, so return as-is
+    return obj;
+}
+/**
+ * Create a shallow copy of an array
+ */
+export function pdfCopyArray(array) {
+    return array.copy();
+}
+/**
+ * Create a shallow copy of a dictionary
+ */
+export function pdfCopyDict(dict) {
+    return dict.copy();
+}
+// ============================================================================
+// Type Checking Functions
+// ============================================================================
+/**
+ * Check if object is null
+ */
+export function isNull(obj) {
+    return obj.isNull;
+}
+/**
+ * Check if object is a boolean
+ */
+export function isBool(obj) {
+    return obj.isBool;
+}
+/**
+ * Check if object is an integer
+ */
+export function isInt(obj) {
+    return obj.isInt;
+}
+/**
+ * Check if object is a real number
+ */
+export function isReal(obj) {
+    return obj.isReal;
+}
+/**
+ * Check if object is a number (int or real)
+ */
+export function isNumber(obj) {
+    return obj.isNumber;
+}
+/**
+ * Check if object is a name
+ */
+export function isName(obj) {
+    return obj.isName;
+}
+/**
+ * Check if object is a string
+ */
+export function isString(obj) {
+    return obj.isString;
+}
+/**
+ * Check if object is an array
+ */
+export function isArray(obj) {
+    return obj.isArray;
+}
+/**
+ * Check if object is a dictionary
+ */
+export function isDict(obj) {
+    return obj.isDict;
+}
+/**
+ * Check if object is a stream
+ */
+export function isStream(obj) {
+    return obj.isStream;
+}
+/**
+ * Check if object is an indirect reference
+ */
+export function isIndirect(obj) {
+    return obj.isIndirect;
+}
+// ============================================================================
+// Value Extraction Functions (with defaults)
+// ============================================================================
+/**
+ * Convert object to boolean with default value
+ */
+export function toBoolDefault(obj, defaultValue) {
+    return obj ? obj.toBool() : defaultValue;
+}
+/**
+ * Convert object to integer with default value
+ */
+export function toIntDefault(obj, defaultValue) {
+    return obj ? obj.toInt() : defaultValue;
+}
+/**
+ * Convert object to real with default value
+ */
+export function toRealDefault(obj, defaultValue) {
+    return obj ? obj.toReal() : defaultValue;
+}
+/**
+ * Get object number from indirect reference
+ */
+export function toObjNum(obj) {
+    if (obj instanceof PdfIndirectRef) {
+        return obj.objNum;
+    }
+    return 0;
+}
+/**
+ * Get generation number from indirect reference
+ */
+export function toGenNum(obj) {
+    if (obj instanceof PdfIndirectRef) {
+        return obj.genNum;
+    }
+    return 0;
+}
+// ============================================================================
+// Reference Counting Functions
+// ============================================================================
+/**
+ * Increment reference count on object
+ */
+export function pdfKeepObj(obj) {
+    return obj.keep();
+}
+/**
+ * Decrement reference count on object
+ */
+export function pdfDropObj(obj) {
+    obj.drop();
+}
+/**
+ * Get reference count for object
+ */
+export function pdfObjRefs(obj) {
+    return obj.getRefs();
+}
+// ============================================================================
+// Object Marking Functions
+// ============================================================================
+/**
+ * Check if object is marked
+ */
+export function pdfObjMarked(obj) {
+    return obj.isMarked();
+}
+/**
+ * Mark an object
+ */
+export function pdfMarkObj(obj) {
+    obj.mark();
+}
+/**
+ * Unmark an object
+ */
+export function pdfUnmarkObj(obj) {
+    obj.unmark();
+}
+/**
+ * Set parent object number
+ */
+export function pdfSetObjParent(obj, parentNum) {
+    obj.setParent(parentNum);
+}
+/**
+ * Get parent object number
+ */
+export function pdfObjParentNum(obj) {
+    return obj.getParentNum();
+}
+// ============================================================================
+// Geometry Creation Utilities
+// ============================================================================
+/**
+ * Create a point dictionary (for use in PDF objects)
+ */
+export function pdfNewPoint(x, y) {
+    return pdfArray([pdfReal(x), pdfReal(y)]);
+}
+/**
+ * Create a rectangle dictionary (for use in PDF objects)
+ */
+export function pdfNewRect(x0, y0, x1, y1) {
+    return pdfArray([pdfReal(x0), pdfReal(y0), pdfReal(x1), pdfReal(y1)]);
+}
+/**
+ * Create a matrix dictionary (for use in PDF objects)
+ */
+export function pdfNewMatrix(a, b, c, d, e, f) {
+    return pdfArray([pdfReal(a), pdfReal(b), pdfReal(c), pdfReal(d), pdfReal(e), pdfReal(f)]);
+}
+/**
+ * Create a date string in PDF format
+ * Format: D:YYYYMMDDHHmmSSOHH'mm
+ */
+export function pdfNewDate(date = new Date()) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    // Get timezone offset
+    const offset = -date.getTimezoneOffset();
+    const offsetSign = offset >= 0 ? '+' : '-';
+    const offsetHours = String(Math.floor(Math.abs(offset) / 60)).padStart(2, '0');
+    const offsetMinutes = String(Math.abs(offset) % 60).padStart(2, '0');
+    const dateStr = `D:${year}${month}${day}${hours}${minutes}${seconds}${offsetSign}${offsetHours}'${offsetMinutes}`;
+    return pdfString(dateStr);
+}
+// ============================================================================
+// Dictionary Utility Functions
+// ============================================================================
+/**
+ * Get key at index from dictionary (for iteration)
+ */
+export function pdfDictGetKey(dict, index) {
+    const keys = dict.keys();
+    return keys[index];
+}
+/**
+ * Get value at index from dictionary (for iteration)
+ */
+export function pdfDictGetVal(dict, index) {
+    const key = pdfDictGetKey(dict, index);
+    return key ? dict.get(key) : undefined;
+}
+// ============================================================================
+// Indirect Reference Resolution
+// ============================================================================
+// Note: These functions require document context for actual resolution
+// Here we provide type-level support; actual resolution happens in Document class
+/**
+ * Check if an indirect reference is resolved
+ * @param obj The object to check
+ * @returns Always true for direct objects, requires document context for indirect refs
+ */
+export function pdfObjIsResolved(obj) {
+    // Direct objects are always "resolved"
+    if (!(obj instanceof PdfIndirectRef)) {
+        return true;
+    }
+    // Indirect references need document context to resolve
+    // This is a placeholder - actual resolution requires document
+    return false;
+}
+/**
+ * Resolve an indirect reference (stub - requires document context)
+ * @param obj The object to resolve
+ * @returns The same object (actual resolution requires document)
+ */
+export function pdfResolveIndirect(obj) {
+    // In actual implementation, this would look up the object in the document
+    // For now, return as-is
+    return obj;
+}
+/**
+ * Load an object from document (stub - requires document context)
+ * @param objNum Object number
+ * @param genNum Generation number
+ * @returns undefined (actual loading requires document)
+ */
+export function pdfLoadObject(_objNum, _genNum) {
+    // This is a placeholder - actual implementation would load from document
+    // The real implementation will be in the Document class
+    return undefined;
+}
+//# sourceMappingURL=object.js.map