pdf-lite 1.4.0 → 1.6.0

package/dist/core/objects/pdf-object.js

@@ -9,10 +9,20 @@ export class PdfObject {
     modified = true;
     /** Indicates whether the object is immutable (cannot be modified) */
     immutable = false;
+    /** Cached byte representation of the object, if available */
+    cachedTokens;
     /** The type of this PDF object */
     get objectType() {
         return this.constructor.name;
     }
+    /**
+     * Returns true if this object's serialized form ends with a self-delimiting
+     * character (e.g., `)`, `>`, `]`, `>>`). Such objects do not require trailing
+     * whitespace before the next token.
+     */
+    get isTrailingDelimited() {
+        return false;
+    }
     /** Indicates whether the object has been modified. Override this method if the modified state is determined differently */
     isModified() {
         return this.modified;
@@ -27,10 +37,22 @@ export class PdfObject {
     }
     /** Sets the immutable state of the object */
     setImmutable(immutable = true) {
+        if (immutable === this.immutable) {
+            return;
+        }
         this.immutable = immutable;
+        if (immutable) {
+            this.cachedTokens = this.toTokens();
+        }
+        else {
+            this.cachedTokens = undefined;
+        }
     }
     /** Converts the object to an array of PdfTokens, including any pre or post tokens */
     toTokens() {
+        if (this.cachedTokens) {
+            return this.cachedTokens;
+        }
         return [
             ...(this.preTokens ?? []),
             ...this.tokenize(),
@@ -90,4 +112,18 @@ export class PdfObject {
         }
         return true;
     }
+    /**
+     * Serializes the document to a Base64-encoded string.
+     *
+     * @returns A promise that resolves to the PDF document as a Base64 string
+     */
+    toBase64() {
+        const bytes = this.toBytes();
+        let binary = '';
+        const len = bytes.byteLength;
+        for (let i = 0; i < len; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
 }

package/dist/core/objects/pdf-start-xref.d.ts

@@ -6,5 +6,6 @@ export declare class PdfStartXRef extends PdfObject {
     constructor(offset?: number | PdfNumber | Ref<number>);
     protected tokenize(): import("../index.js").PdfToken[];
     cloneImpl(): this;
+    setModified(modified?: boolean): void;
     isModified(): boolean;
 }

package/dist/core/objects/pdf-start-xref.js

@@ -27,6 +27,10 @@ export class PdfStartXRef extends PdfObject {
         const cloned = new PdfStartXRef(this.offset.clone());
         return cloned;
     }
+    setModified(modified) {
+        super.setModified(modified);
+        this.offset.setModified(modified);
+    }
     isModified() {
         return super.isModified() || this.offset.isModified();
     }

package/dist/core/objects/pdf-stream.d.ts

@@ -1,12 +1,48 @@
 import { PdfToken } from '../tokens/token.js';
 import { PdfDictionary } from './pdf-dictionary.js';
 import { PdfObject } from './pdf-object.js';
-import { ByteArray } from '../../types.js';
+import { ByteArray, DecodeParms } from '../../types.js';
 import { PdfNumber } from './pdf-number.js';
 import { PdfIndirectObject } from './pdf-indirect-object.js';
 import { PdfXRefTableEntry } from './pdf-xref-table.js';
 import { PdfFilter, PdfStreamFilterType } from '../../filters/types.js';
+export declare class PdfStreamPredictor extends PdfDictionary<{
+    Predictor?: PdfNumber;
+    Columns?: PdfNumber;
+    Colors?: PdfNumber;
+    BitsPerComponent?: PdfNumber;
+}> {
+    static NONE: PdfStreamPredictor;
+    static TIFF: PdfStreamPredictor;
+    static PNG_NONE: PdfStreamPredictor;
+    static PNG_SUB: PdfStreamPredictor;
+    static PNG_UP: PdfStreamPredictor;
+    static PNG_AVERAGE: PdfStreamPredictor;
+    static PNG_PAETH: PdfStreamPredictor;
+    static PNG_OPTIMUM: PdfStreamPredictor;
+    static XREF_STREAM: PdfStreamPredictor;
+    get predictor(): number;
+    set predictor(value: number);
+    get columns(): number;
+    set columns(value: number);
+    get colors(): number;
+    set colors(value: number);
+    get bitsPerComponent(): number;
+    set bitsPerComponent(value: number);
+    toDecodeParms(): DecodeParms;
+    cloneImpl(): this;
+    static fromDecodeParms(params: DecodeParms): PdfStreamPredictor;
+    static fromDictionary(dict?: PdfDictionary): PdfStreamPredictor | undefined;
+    encode(data: ByteArray, filterType?: number): ByteArray;
+    decode(data: ByteArray): ByteArray;
+    private static tiffDecode;
+    private static tiffEncode;
+    private static pngDecode;
+    private static pngEncode;
+    private static paethPredictor;
+}
 export declare class PdfStream<T extends PdfDictionary = PdfDictionary> extends PdfObject {
+    static PdfStreamPredictor: typeof PdfStreamPredictor;
     header: T;
     original: ByteArray;
     preStreamDataTokens?: PdfToken[];
@@ -20,14 +56,15 @@ export declare class PdfStream<T extends PdfDictionary = PdfDictionary> extends
     set raw(data: ByteArray);
     get originalAsString(): string;
     get rawAsString(): string;
+    set rawAsString(str: string);
+    get data(): ByteArray;
+    set data(data: ByteArray);
+    get dataAsString(): string;
+    set dataAsString(str: string);
     getFilters(): PdfStreamFilterType[];
     addFilter(filterName: PdfStreamFilterType): this;
-    setPredictor(predictorParams: {
-        Predictor?: number;
-        Columns?: number;
-        Colors?: number;
-        BitsPerComponent?: number;
-    }): this;
+    get predictor(): PdfStreamPredictor | undefined;
+    set predictor(predictor: PdfStreamPredictor);
     removeFilter(filterName: PdfStreamFilterType): this;
     removePredictor(): this;
     removeAllFilters(): this;

package/dist/core/objects/pdf-stream.js

@@ -12,12 +12,244 @@ import { lzw } from '../../filters/lzw.js';
 import { runLength } from '../../filters/runlength.js';
 import { passthroughFilter } from '../../filters/pass-through.js';
 import { PdfNumber } from './pdf-number.js';
-import { Predictor } from '../../utils/predictors.js';
 import { bytesToPdfObjects } from '../generators.js';
 import { PdfIndirectObject } from './pdf-indirect-object.js';
 import { PdfXRefTableEntry } from './pdf-xref-table.js';
 import { stringToBytes } from '../../utils/stringToBytes.js';
+import { bytesToString } from '../../utils/bytesToString.js';
+export class PdfStreamPredictor extends PdfDictionary {
+    static NONE = new PdfStreamPredictor({ Predictor: new PdfNumber(1) });
+    static TIFF = new PdfStreamPredictor({ Predictor: new PdfNumber(2) });
+    static PNG_NONE = new PdfStreamPredictor({ Predictor: new PdfNumber(10) });
+    static PNG_SUB = new PdfStreamPredictor({ Predictor: new PdfNumber(11) });
+    static PNG_UP = new PdfStreamPredictor({ Predictor: new PdfNumber(12) });
+    static PNG_AVERAGE = new PdfStreamPredictor({
+        Predictor: new PdfNumber(13),
+    });
+    static PNG_PAETH = new PdfStreamPredictor({ Predictor: new PdfNumber(14) });
+    static PNG_OPTIMUM = new PdfStreamPredictor({
+        Predictor: new PdfNumber(15),
+    });
+    static XREF_STREAM = new PdfStreamPredictor({
+        Predictor: new PdfNumber(12),
+        Columns: new PdfNumber(7),
+    });
+    get predictor() {
+        return this.get('Predictor')?.as(PdfNumber)?.value ?? 1;
+    }
+    set predictor(value) {
+        this.set('Predictor', new PdfNumber(value));
+    }
+    get columns() {
+        return this.get('Columns')?.as(PdfNumber)?.value ?? 1;
+    }
+    set columns(value) {
+        this.set('Columns', new PdfNumber(value));
+    }
+    get colors() {
+        return this.get('Colors')?.as(PdfNumber)?.value ?? 1;
+    }
+    set colors(value) {
+        this.set('Colors', new PdfNumber(value));
+    }
+    get bitsPerComponent() {
+        return this.get('BitsPerComponent')?.as(PdfNumber)?.value ?? 8;
+    }
+    set bitsPerComponent(value) {
+        this.set('BitsPerComponent', new PdfNumber(value));
+    }
+    toDecodeParms() {
+        const params = {};
+        const predictor = this.get('Predictor')?.as(PdfNumber);
+        if (predictor)
+            params.Predictor = predictor.value;
+        const columns = this.get('Columns')?.as(PdfNumber);
+        if (columns)
+            params.Columns = columns.value;
+        const colors = this.get('Colors')?.as(PdfNumber);
+        if (colors)
+            params.Colors = colors.value;
+        const bpc = this.get('BitsPerComponent')?.as(PdfNumber);
+        if (bpc)
+            params.BitsPerComponent = bpc.value;
+        return params;
+    }
+    cloneImpl() {
+        return PdfStreamPredictor.fromDecodeParms(this.toDecodeParms());
+    }
+    static fromDecodeParms(params) {
+        const predictor = new PdfStreamPredictor();
+        if (params.Predictor !== undefined) {
+            predictor.predictor = params.Predictor;
+        }
+        if (params.Columns !== undefined) {
+            predictor.columns = params.Columns;
+        }
+        if (params.Colors !== undefined) {
+            predictor.colors = params.Colors;
+        }
+        if (params.BitsPerComponent !== undefined) {
+            predictor.bitsPerComponent = params.BitsPerComponent;
+        }
+        return predictor;
+    }
+    static fromDictionary(dict) {
+        if (!dict)
+            return undefined;
+        const predictor = dict.get('Predictor')?.as(PdfNumber)?.value;
+        if (predictor === undefined || predictor <= 1 || predictor > 15) {
+            return undefined;
+        }
+        return PdfStreamPredictor.fromDecodeParms({
+            Predictor: predictor,
+            Columns: dict.get('Columns')?.as(PdfNumber)?.value,
+            Colors: dict.get('Colors')?.as(PdfNumber)?.value,
+            BitsPerComponent: dict.get('BitsPerComponent')?.as(PdfNumber)
+                ?.value,
+        });
+    }
+    encode(data, filterType = 0) {
+        const bpp = Math.ceil((this.colors * this.bitsPerComponent) / 8);
+        if (this.predictor === 2) {
+            return PdfStreamPredictor.tiffEncode(data, this.columns, bpp);
+        }
+        else if (this.predictor >= 10 && this.predictor <= 15) {
+            return PdfStreamPredictor.pngEncode(data, this.columns, bpp, filterType);
+        }
+        return data;
+    }
+    decode(data) {
+        const bpp = Math.ceil((this.colors * this.bitsPerComponent) / 8);
+        if (this.predictor === 2) {
+            return PdfStreamPredictor.tiffDecode(data, this.columns, bpp);
+        }
+        else if (this.predictor >= 10 && this.predictor <= 15) {
+            return PdfStreamPredictor.pngDecode(data, this.columns, bpp);
+        }
+        return data;
+    }
+    static tiffDecode(data, columns, bpp) {
+        const rowLength = columns * bpp;
+        const output = new Uint8Array(data.length);
+        for (let i = 0; i < data.length; i += rowLength) {
+            for (let j = 0; j < rowLength; j++) {
+                output[i + j] =
+                    j < bpp
+                        ? data[i + j]
+                        : (data[i + j] + output[i + j - bpp]) & 0xff;
+            }
+        }
+        return output;
+    }
+    static tiffEncode(data, columns, bpp) {
+        const rowLength = columns * bpp;
+        const output = new Uint8Array(data.length);
+        for (let i = 0; i < data.length; i += rowLength) {
+            for (let j = 0; j < rowLength; j++) {
+                output[i + j] =
+                    j < bpp
+                        ? data[i + j]
+                        : (data[i + j] - data[i + j - bpp] + 256) & 0xff;
+            }
+        }
+        return output;
+    }
+    static pngDecode(data, columns, bpp) {
+        const rowLength = columns * bpp;
+        const output = [];
+        for (let i = 0; i < data.length;) {
+            const filter = data[i];
+            const row = data.slice(i + 1, i + 1 + rowLength);
+            const prior = output.slice(output.length - rowLength, output.length);
+            const decodedRow = new Uint8Array(rowLength);
+            for (let j = 0; j < rowLength; j++) {
+                const left = j >= bpp ? decodedRow[j - bpp] : 0;
+                const up = prior[j] ?? 0;
+                const upperLeft = j >= bpp ? (prior[j - bpp] ?? 0) : 0;
+                switch (filter) {
+                    case 0:
+                        decodedRow[j] = row[j];
+                        break;
+                    case 1:
+                        decodedRow[j] = (row[j] + left) & 0xff;
+                        break;
+                    case 2:
+                        decodedRow[j] = (row[j] + up) & 0xff;
+                        break;
+                    case 3:
+                        decodedRow[j] =
+                            (row[j] + Math.floor((left + up) / 2)) & 0xff;
+                        break;
+                    case 4:
+                        decodedRow[j] =
+                            (row[j] +
+                                this.paethPredictor(left, up, upperLeft)) &
+                                0xff;
+                        break;
+                    default:
+                        throw new Error(`Unsupported PNG filter: ${filter}`);
+                }
+            }
+            output.push(...decodedRow);
+            i += 1 + rowLength;
+        }
+        return new Uint8Array(output);
+    }
+    static pngEncode(data, columns, bpp, filterType) {
+        const rowLength = columns * bpp;
+        const output = [];
+        let prior = new Uint8Array(rowLength);
+        for (let i = 0; i < data.length; i += rowLength) {
+            const row = data.slice(i, i + rowLength);
+            const encodedRow = new Uint8Array(rowLength);
+            for (let j = 0; j < rowLength; j++) {
+                const left = j >= bpp ? row[j - bpp] : 0;
+                const up = prior[j] ?? 0;
+                const upperLeft = j >= bpp ? (prior[j - bpp] ?? 0) : 0;
+                switch (filterType) {
+                    case 0:
+                        encodedRow[j] = row[j];
+                        break;
+                    case 1:
+                        encodedRow[j] = (row[j] - left + 256) & 0xff;
+                        break;
+                    case 2:
+                        encodedRow[j] = (row[j] - up + 256) & 0xff;
+                        break;
+                    case 3:
+                        encodedRow[j] =
+                            (row[j] - Math.floor((left + up) / 2) + 256) & 0xff;
+                        break;
+                    case 4:
+                        encodedRow[j] =
+                            (row[j] -
+                                this.paethPredictor(left, up, upperLeft) +
+                                256) &
+                                0xff;
+                        break;
+                    default:
+                        throw new Error(`Unsupported PNG filter: ${filterType}`);
+                }
+            }
+            output.push(filterType, ...encodedRow);
+            prior = row;
+        }
+        return new Uint8Array(output);
+    }
+    static paethPredictor(a, b, c) {
+        const p = a + b - c;
+        const pa = Math.abs(p - a);
+        const pb = Math.abs(p - b);
+        const pc = Math.abs(p - c);
+        if (pa <= pb && pa <= pc)
+            return a;
+        if (pb <= pc)
+            return b;
+        return c;
+    }
+}
 export class PdfStream extends PdfObject {
+    static PdfStreamPredictor = PdfStreamPredictor;
     header;
     original;
     preStreamDataTokens;
@@ -44,18 +276,40 @@ export class PdfStream extends PdfObject {
         return this.original.slice(0, length);
     }
     set raw(data) {
-        if (this.isImmutable()) {
-            throw new Error('Cannot modify an immutable PdfStream');
-        }
         this.setModified();
         this.original = data;
         this.header.set('Length', new PdfNumber(data.length));
     }
     get originalAsString() {
-        return new TextDecoder().decode(this.original);
+        return bytesToString(this.original);
     }
     get rawAsString() {
-        return new TextDecoder().decode(this.raw);
+        return bytesToString(this.raw);
+    }
+    set rawAsString(str) {
+        this.raw = stringToBytes(str);
+    }
+    get data() {
+        return this.decode();
+    }
+    set data(data) {
+        const filters = this.getFilters();
+        const existingPredictor = this.predictor;
+        this.removeAllFilters();
+        this.header.delete('DecodeParms');
+        this.raw = data;
+        if (existingPredictor) {
+            this.predictor = existingPredictor;
+        }
+        for (const filter of filters) {
+            this.addFilter(filter);
+        }
+    }
+    get dataAsString() {
+        return bytesToString(this.data);
+    }
+    set dataAsString(str) {
+        this.data = stringToBytes(str);
     }
     getFilters() {
         const filters = this.header.get('Filter');
@@ -90,23 +344,24 @@ export class PdfStream extends PdfObject {
         this.raw = filter.encode(this.raw);
         return this;
     }
-    setPredictor(predictorParams) {
-        let decodeParms = this.header.get('DecodeParms')?.as(PdfDictionary);
-        if (!decodeParms) {
-            decodeParms = new PdfDictionary();
-            this.header.set('DecodeParms', decodeParms);
+    get predictor() {
+        const raw = this.header.get('DecodeParms');
+        if (!raw)
+            return undefined;
+        if (raw instanceof PdfStreamPredictor) {
+            if (raw.get('Predictor') === undefined)
+                return undefined;
+            return raw;
         }
-        else if (decodeParms instanceof PdfDictionary) {
-            // already a dictionary
+        if (raw instanceof PdfDictionary) {
+            return PdfStreamPredictor.fromDictionary(raw);
         }
-        else {
-            throw new Error('Invalid DecodeParms entry in PDF stream');
-        }
-        for (const [key, value] of Object.entries(predictorParams)) {
-            decodeParms.set(key, new PdfNumber(value));
-        }
-        this.raw = Predictor.encode(this.raw, predictorParams);
-        return this;
+        return undefined;
+    }
+    set predictor(predictor) {
+        const cloned = predictor.cloneImpl();
+        this.header.set('DecodeParms', cloned);
+        this.raw = cloned.encode(this.raw);
     }
     removeFilter(filterName) {
         let filters = this.header.get('Filter');
@@ -155,9 +410,9 @@ export class PdfStream extends PdfObject {
             const filter = PdfStream.getFilter(filterName);
             data = filter.decode(data);
         }
-        const predictorParams = Predictor.getDecodeParms(this.header.get('DecodeParms')?.as(PdfDictionary));
-        if (predictorParams) {
-            data = Predictor.decode(data, predictorParams);
+        const streamPredictor = PdfStreamPredictor.fromDictionary(this.header.get('DecodeParms')?.as(PdfDictionary));
+        if (streamPredictor) {
+            data = streamPredictor.decode(data);
         }
         return data;
     }
@@ -303,11 +558,14 @@ export class PdfObjStream extends PdfStream {
                 // After that come the actual objects
                 const objectNumber = numbers[i * 2].value;
                 const generationNumber = 0;
-                yield new PdfIndirectObject({
+                const decompressedObject = new PdfIndirectObject({
                     objectNumber,
                     generationNumber,
                     content: obj,
-                });
+                    compressed: true,
+                }).clone();
+                decompressedObject.setModified(false);
+                yield decompressedObject;
                 i++;
                 // Stop after we've read N objects
                 if (totalObjects > 0 && i >= totalObjects) {

package/dist/core/objects/pdf-string.d.ts

@@ -21,6 +21,7 @@ export declare class PdfString extends PdfObject {
     get isUTF16BE(): boolean;
     set value(str: string);
     get value(): string;
+    get isTrailingDelimited(): boolean;
     protected tokenize(): PdfStringToken[];
     cloneImpl(): this;
 }

package/dist/core/objects/pdf-string.js

@@ -37,9 +37,6 @@ export class PdfString extends PdfObject {
         return this._raw;
     }
     set raw(raw) {
-        if (this.isImmutable()) {
-            throw new Error('Cannot modify an immutable PdfString');
-        }
         this.setModified();
         this._raw = raw;
         // Clear original bytes when modified
@@ -53,9 +50,6 @@ export class PdfString extends PdfObject {
         return (this.raw.length >= 2 && this.raw[0] === 0xfe && this.raw[1] === 0xff);
     }
     set value(str) {
-        if (this.isImmutable()) {
-            throw new Error('Cannot modify an immutable PdfString');
-        }
         this.setModified();
         if (needsUnicodeEncoding(str)) {
             this._raw = encodeAsUTF16BE(str);
@@ -74,6 +68,9 @@ export class PdfString extends PdfObject {
         // Default: use PDFDocEncoding
         return decodeFromPDFDocEncoding(this.raw);
     }
+    get isTrailingDelimited() {
+        return true;
+    }
     tokenize() {
         return [new PdfStringToken(this.raw, this._originalBytes)];
     }

package/dist/core/objects/pdf-trailer.d.ts

@@ -22,5 +22,6 @@ export declare class PdfTrailer extends PdfObject {
     constructor(entries: PdfTrailerEntries | PdfDictionary<PdfTrailerEntries>);
     protected tokenize(): PdfToken[];
     cloneImpl(): this;
+    setModified(modified?: boolean): void;
     isModified(): boolean;
 }

package/dist/core/objects/pdf-trailer.js

@@ -26,9 +26,12 @@ export class PdfTrailer extends PdfObject {
         const cloned = new PdfTrailer(this.dict.clone());
         return cloned;
     }
+    setModified(modified) {
+        super.setModified(modified);
+        this.dict.setModified(modified);
+        this.offset.setModified(modified);
+    }
     isModified() {
-        return (super.isModified() ||
-            this.dict.isModified() ||
-            this.offset.isModified);
+        return (super.isModified() || this.dict.isModified() || this.offset.modified);
     }
 }

package/dist/core/objects/pdf-xref-table.js

@@ -87,7 +87,7 @@ export class PdfXRefTable extends PdfObject {
         return (super.isModified() ||
             this.sections.some((section) => section.isModified()) ||
             this.entries.some((entry) => entry.isModified()) ||
-            this.offset.isModified);
+            this.offset.modified);
     }
     addEntryForObject(obj) {
         const foundEntry = this.entries.find((entry) => entry.objectNumber.value === obj.objectNumber);

package/dist/core/parser/incremental-parser.d.ts

@@ -1,17 +1,4 @@
 import { Parser } from './parser.js';
-/**
- * Error thrown when the parser needs more input to continue parsing.
- */
-export declare class NoMoreTokensError extends Error {
-}
-/**
- * Error thrown when the end of file has been reached and no more input is available.
- */
-export declare class EofReachedError extends Error {
-}
-export declare class UnexpectedTokenError extends Error {
-    constructor(expected: string, actual: string | null);
-}
 /**
  * Abstract base class for incremental parsers that can process input as it becomes available.
  * Supports buffering, lookahead, and backtracking for complex parsing scenarios.

package/dist/core/parser/incremental-parser.js

@@ -1,22 +1,5 @@
 import { Parser } from './parser.js';
-/**
- * Error thrown when the parser needs more input to continue parsing.
- */
-export class NoMoreTokensError extends Error {
-}
-/**
- * Error thrown when the end of file has been reached and no more input is available.
- */
-export class EofReachedError extends Error {
-}
-/*
- * Error thrown when an unexpected token is encountered during parsing.
- */
-export class UnexpectedTokenError extends Error {
-    constructor(expected, actual) {
-        super(`Unexpected token: expected ${expected}, but got ${actual === null ? 'EOF' : actual}`);
-    }
-}
+import { NoMoreTokensError, EofReachedError } from '../../errors.js';
 /**
  * Abstract base class for incremental parsers that can process input as it becomes available.
  * Supports buffering, lookahead, and backtracking for complex parsing scenarios.

package/dist/core/ref.d.ts

@@ -22,7 +22,7 @@ export declare class Ref<T> {
     value: T | Ref<T>;
     /** Registered callbacks for update notifications */
     callbacks: Array<RefUpdateCallback<T>>;
-    isModified: boolean;
+    modified: boolean;
     protected immutable: boolean;
     /**
      * Creates a new Ref with an initial value.
@@ -31,6 +31,8 @@ export declare class Ref<T> {
      * @throws Error if attempting to create a self-referencing Ref
      */
     constructor(value: T | Ref<T>);
+    isModified(): boolean;
+    setModified(modified?: boolean): void;
     setImmutable(immutable?: boolean): void;
     isImmutable(): boolean;
     /**

package/dist/core/ref.js

@@ -16,7 +16,7 @@ export class Ref {
     value;
     /** Registered callbacks for update notifications */
     callbacks = [];
-    isModified = false;
+    modified = true;
     immutable = false;
     /**
      * Creates a new Ref with an initial value.
@@ -30,6 +30,12 @@ export class Ref {
         }
         this.value = value;
     }
+    isModified() {
+        return this.modified;
+    }
+    setModified(modified = true) {
+        this.modified = modified;
+    }
     setImmutable(immutable = true) {
         this.immutable = immutable;
     }
@@ -49,10 +55,7 @@ export class Ref {
         const resolvedNewValue = newValue instanceof Ref ? newValue.resolve() : newValue;
         const oldValue = this.resolve();
         if (oldValue !== resolvedNewValue) {
-            if (this.immutable) {
-                throw new Error(`Cannot update an immutable Ref (${oldValue} -> ${resolvedNewValue})`);
-            }
-            this.isModified = true;
+            this.modified = true;
         }
         this.value = newValue;
         this.callbacks.forEach((cb) => cb(oldValue, this.resolve()));