@sdcorejs/angular 20.1.3 → 20.1.5

package/fesm2022/sdcorejs-angular-services-persistence.mjs

@@ -0,0 +1,899 @@
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import * as i0 from '@angular/core';
+import { inject, PLATFORM_ID, Injectable, InjectionToken } from '@angular/core';
+
+const SD_GRAPH_FORMAT = 'sdcorejs.graph';
+const SD_GRAPH_VERSION = 1;
+
+const DATE_GET_TIME = Date.prototype.getTime;
+const DATE_TO_ISO_STRING = Date.prototype.toISOString;
+const MAP_ENTRIES = Map.prototype.entries;
+const MAP_SET = Map.prototype.set;
+const SET_VALUES = Set.prototype.values;
+const SET_ADD = Set.prototype.add;
+const SD_GRAPH_HARD_LIMITS = Object.freeze({
+    maxDocumentCharacters: 4_000_000,
+    maxDepth: 128,
+    maxNodes: 50_000,
+    maxEntries: 200_000,
+    maxStringCharacters: 1_000_000,
+    maxKeyCharacters: 16_384,
+    maxBigIntDigits: 100_000,
+});
+class SdPersistenceError extends Error {
+    code;
+    name = 'SdPersistenceError';
+    constructor(code, message) {
+        super(`${code}: ${message}`);
+        this.code = code;
+    }
+}
+class SdGraphSerializer {
+    format = `${SD_GRAPH_FORMAT}@${SD_GRAPH_VERSION}`;
+    limits;
+    constructor(limits = {}) {
+        const configured = { ...SD_GRAPH_HARD_LIMITS, ...limits };
+        for (const key of Object.keys(SD_GRAPH_HARD_LIMITS)) {
+            const value = configured[key];
+            if (!Number.isSafeInteger(value) || value < 1 || value > SD_GRAPH_HARD_LIMITS[key]) {
+                throw new SdPersistenceError('LIMIT_EXCEEDED', `Invalid ${key} limit`);
+            }
+        }
+        this.limits = Object.freeze(configured);
+    }
+    stringify(value) {
+        const nodes = [];
+        const references = new Map();
+        const budget = { entries: 0 };
+        const root = this.#encode(value, nodes, references, '$', 0, budget);
+        const envelope = {
+            format: SD_GRAPH_FORMAT,
+            version: SD_GRAPH_VERSION,
+            root,
+            nodes,
+        };
+        const serialized = JSON.stringify(envelope);
+        this.#ensureDocumentLength(serialized.length);
+        return serialized;
+    }
+    parse(serialized) {
+        this.#ensureDocumentLength(serialized.length);
+        let document;
+        try {
+            document = JSON.parse(serialized);
+        }
+        catch {
+            throw new SdPersistenceError('INVALID_DOCUMENT', 'Serialized value is not valid JSON');
+        }
+        const envelope = this.#validateEnvelope(document);
+        this.#validateDepth(envelope);
+        const values = envelope.nodes.map((node, index) => this.#createNode(node, index));
+        envelope.nodes.forEach((node, index) => this.#populateNode(node, values[index], values));
+        return this.#decode(envelope.root, values, '$.root');
+    }
+    clone(value) {
+        return this.parse(this.stringify(value));
+    }
+    #encode(value, nodes, references, path, depth, budget) {
+        this.#ensureDepth(depth, path);
+        if (value === null || typeof value === 'boolean')
+            return value;
+        if (typeof value === 'string') {
+            this.#ensureStringLength(value, path);
+            return value;
+        }
+        if (value === undefined)
+            return { $type: 'undefined' };
+        if (typeof value === 'number') {
+            if (Number.isNaN(value))
+                return { $type: 'number', value: 'NaN' };
+            if (value === Number.POSITIVE_INFINITY)
+                return { $type: 'number', value: 'Infinity' };
+            if (value === Number.NEGATIVE_INFINITY)
+                return { $type: 'number', value: '-Infinity' };
+            if (Object.is(value, -0))
+                return { $type: 'number', value: '-0' };
+            return value;
+        }
+        if (typeof value === 'bigint') {
+            const bigint = value.toString();
+            this.#ensureBigIntLength(bigint, path);
+            return { $type: 'bigint', value: bigint };
+        }
+        if (typeof value === 'function' || typeof value === 'symbol') {
+            throw new SdPersistenceError('UNSUPPORTED_VALUE', `Unsupported ${typeof value} at ${path}`);
+        }
+        const prototype = Object.getPrototypeOf(value);
+        if (Array.isArray(value) && prototype !== Array.prototype) {
+            throw new SdPersistenceError('UNSUPPORTED_VALUE', `Unsupported array prototype at ${path}`);
+        }
+        const existingReference = references.get(value);
+        if (existingReference !== undefined)
+            return { $ref: existingReference };
+        const reference = nodes.length;
+        references.set(value, reference);
+        if (Array.isArray(value)) {
+            this.#addNode(nodes, { type: 'array', values: [] }, path);
+            this.#consumeEntries(value.length, path, budget);
+            const node = nodes[reference];
+            if (node.type !== 'array')
+                throw new SdPersistenceError('INVALID_NODE', `Invalid array node at ${path}`);
+            if (Object.getOwnPropertySymbols(value).length > 0) {
+                throw new SdPersistenceError('UNSUPPORTED_VALUE', `Symbol properties are unsupported at ${path}`);
+            }
+            const descriptors = Object.getOwnPropertyDescriptors(value);
+            for (const key of Object.keys(descriptors)) {
+                if (key === 'length')
+                    continue;
+                if (!this.#isArrayIndex(key, value.length)) {
+                    throw new SdPersistenceError('UNSUPPORTED_VALUE', `Extra array property is unsupported at ${path}.${key}`);
+                }
+            }
+            for (let index = 0; index < value.length; index += 1) {
+                const descriptor = descriptors[String(index)];
+                if (!descriptor) {
+                    throw new SdPersistenceError('UNSUPPORTED_VALUE', `Sparse array entry is unsupported at ${path}[${index}]`);
+                }
+                if (!('value' in descriptor)) {
+                    throw new SdPersistenceError('UNSUPPORTED_VALUE', `Accessor property is unsupported at ${path}[${index}]`);
+                }
+                node.values.push(this.#encode(descriptor.value, nodes, references, `${path}[${index}]`, depth + 1, budget));
+            }
+            return { $ref: reference };
+        }
+        if (prototype === Date.prototype) {
+            this.#ensureNoOwnProperties(value, path, 'Date');
+            let time;
+            let iso;
+            try {
+                time = DATE_GET_TIME.call(value);
+                iso = DATE_TO_ISO_STRING.call(value);
+            }
+            catch {
+                throw new SdPersistenceError('UNSUPPORTED_VALUE', `Invalid Date at ${path}`);
+            }
+            if (!Number.isFinite(time))
+                throw new SdPersistenceError('UNSUPPORTED_VALUE', `Invalid Date at ${path}`);
+            this.#addNode(nodes, { type: 'date', value: iso }, path);
+            return { $ref: reference };
+        }
+        if (prototype === Map.prototype) {
+            this.#ensureNoOwnProperties(value, path, 'Map');
+            let iterator;
+            try {
+                iterator = MAP_ENTRIES.call(value);
+            }
+            catch {
+                throw new SdPersistenceError('UNSUPPORTED_VALUE', `Invalid Map at ${path}`);
+            }
+            const node = { type: 'map', entries: [] };
+            this.#addNode(nodes, node, path);
+            let index = 0;
+            for (const [key, item] of iterator) {
+                this.#consumeEntries(1, path, budget);
+                node.entries.push([
+                    this.#encode(key, nodes, references, `${path}.mapKey[${index}]`, depth + 1, budget),
+                    this.#encode(item, nodes, references, `${path}.mapValue[${index}]`, depth + 1, budget),
+                ]);
+                index += 1;
+            }
+            return { $ref: reference };
+        }
+        if (prototype === Set.prototype) {
+            this.#ensureNoOwnProperties(value, path, 'Set');
+            let iterator;
+            try {
+                iterator = SET_VALUES.call(value);
+            }
+            catch {
+                throw new SdPersistenceError('UNSUPPORTED_VALUE', `Invalid Set at ${path}`);
+            }
+            const node = { type: 'set', values: [] };
+            this.#addNode(nodes, node, path);
+            let index = 0;
+            for (const item of iterator) {
+                this.#consumeEntries(1, path, budget);
+                node.values.push(this.#encode(item, nodes, references, `${path}.set[${index}]`, depth + 1, budget));
+                index += 1;
+            }
+            return { $ref: reference };
+        }
+        if (prototype !== Object.prototype && prototype !== null) {
+            throw new SdPersistenceError('UNSUPPORTED_VALUE', `Unsupported object prototype at ${path}`);
+        }
+        if (Object.getOwnPropertySymbols(value).length > 0) {
+            throw new SdPersistenceError('UNSUPPORTED_VALUE', `Symbol properties are unsupported at ${path}`);
+        }
+        const node = {
+            type: 'object',
+            prototype: prototype === null ? 'null' : 'object',
+            entries: [],
+        };
+        this.#addNode(nodes, node, path);
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        const keys = Object.keys(descriptors).sort();
+        this.#consumeEntries(keys.length, path, budget);
+        for (const key of keys) {
+            this.#ensureKeyLength(key, `${path}.${key}`);
+            const descriptor = descriptors[key];
+            if (!descriptor || !('value' in descriptor)) {
+                throw new SdPersistenceError('UNSUPPORTED_VALUE', `Accessor property is unsupported at ${path}.${key}`);
+            }
+            if (!descriptor.enumerable) {
+                throw new SdPersistenceError('UNSUPPORTED_VALUE', `Non-enumerable property is unsupported at ${path}.${key}`);
+            }
+            node.entries.push([key, this.#encode(descriptor.value, nodes, references, `${path}.${key}`, depth + 1, budget)]);
+        }
+        return { $ref: reference };
+    }
+    #validateEnvelope(value) {
+        if (!this.#isRecord(value) || !this.#hasExactKeys(value, ['format', 'version', 'root', 'nodes'])) {
+            throw new SdPersistenceError('INVALID_DOCUMENT', 'Graph envelope must have the exact schema');
+        }
+        if (value['format'] !== SD_GRAPH_FORMAT)
+            throw new SdPersistenceError('UNKNOWN_FORMAT', 'Unknown persistence format');
+        if (value['version'] !== SD_GRAPH_VERSION)
+            throw new SdPersistenceError('UNKNOWN_VERSION', 'Unsupported persistence version');
+        if (!Array.isArray(value['nodes']))
+            throw new SdPersistenceError('INVALID_DOCUMENT', 'Graph nodes must be an array');
+        if (value['nodes'].length > this.limits.maxNodes) {
+            throw new SdPersistenceError('LIMIT_EXCEEDED', 'Graph node limit exceeded at $.nodes');
+        }
+        const budget = { entries: 0 };
+        const nodes = value['nodes'].map((node, index) => this.#validateNode(node, index, budget));
+        const root = this.#validateGraphValue(value['root'], '$.root');
+        return { format: SD_GRAPH_FORMAT, version: SD_GRAPH_VERSION, root, nodes };
+    }
+    #validateNode(value, index, budget) {
+        if (!this.#isRecord(value) || typeof value['type'] !== 'string') {
+            throw new SdPersistenceError('INVALID_NODE', `Invalid node at index ${index}`);
+        }
+        switch (value['type']) {
+            case 'array':
+            case 'set': {
+                if (!this.#hasExactKeys(value, ['type', 'values']) || !Array.isArray(value['values'])) {
+                    throw new SdPersistenceError('INVALID_NODE', `Invalid ${value['type']} node at index ${index}`);
+                }
+                this.#consumeEntries(value['values'].length, `$.nodes[${index}]`, budget);
+                const values = value['values'].map((item, itemIndex) => this.#validateGraphValue(item, `$.nodes[${index}].values[${itemIndex}]`));
+                if (value['type'] === 'set')
+                    this.#rejectDuplicateValues(values, `set node at index ${index}`);
+                return { type: value['type'], values };
+            }
+            case 'object': {
+                if (!this.#hasExactKeys(value, ['type', 'prototype', 'entries']) ||
+                    (value['prototype'] !== 'object' && value['prototype'] !== 'null') ||
+                    !Array.isArray(value['entries'])) {
+                    throw new SdPersistenceError('INVALID_NODE', `Invalid object node at index ${index}`);
+                }
+                this.#consumeEntries(value['entries'].length, `$.nodes[${index}]`, budget);
+                const keys = new Set();
+                const entries = value['entries'].map((entry, entryIndex) => {
+                    if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== 'string') {
+                        throw new SdPersistenceError('INVALID_NODE', `Invalid object entry at index ${index}:${entryIndex}`);
+                    }
+                    this.#ensureKeyLength(entry[0], `$.nodes[${index}].entries[${entryIndex}]`);
+                    if (keys.has(entry[0]))
+                        throw new SdPersistenceError('INVALID_NODE', `Duplicate object key at index ${index}:${entryIndex}`);
+                    keys.add(entry[0]);
+                    return [entry[0], this.#validateGraphValue(entry[1], `$.nodes[${index}].entries[${entryIndex}]`)];
+                });
+                return { type: 'object', prototype: value['prototype'], entries };
+            }
+            case 'date': {
+                if (!this.#hasExactKeys(value, ['type', 'value']) || typeof value['value'] !== 'string') {
+                    throw new SdPersistenceError('INVALID_NODE', `Invalid date node at index ${index}`);
+                }
+                this.#ensureStringLength(value['value'], `$.nodes[${index}].value`);
+                let canonical = false;
+                try {
+                    const date = new Date(value['value']);
+                    canonical = Number.isFinite(DATE_GET_TIME.call(date)) && DATE_TO_ISO_STRING.call(date) === value['value'];
+                }
+                catch {
+                    canonical = false;
+                }
+                if (!canonical)
+                    throw new SdPersistenceError('INVALID_NODE', `Invalid date node at index ${index}`);
+                return { type: 'date', value: value['value'] };
+            }
+            case 'map': {
+                if (!this.#hasExactKeys(value, ['type', 'entries']) || !Array.isArray(value['entries'])) {
+                    throw new SdPersistenceError('INVALID_NODE', `Invalid map node at index ${index}`);
+                }
+                this.#consumeEntries(value['entries'].length, `$.nodes[${index}]`, budget);
+                const seen = new Set();
+                const entries = value['entries'].map((entry, entryIndex) => {
+                    if (!Array.isArray(entry) || entry.length !== 2) {
+                        throw new SdPersistenceError('INVALID_NODE', `Invalid map entry at index ${index}:${entryIndex}`);
+                    }
+                    const key = this.#validateGraphValue(entry[0], `$.nodes[${index}].entries[${entryIndex}].key`);
+                    const signature = this.#graphValueSignature(key);
+                    if (seen.has(signature))
+                        throw new SdPersistenceError('INVALID_NODE', `Duplicate map key at index ${index}:${entryIndex}`);
+                    seen.add(signature);
+                    return [key, this.#validateGraphValue(entry[1], `$.nodes[${index}].entries[${entryIndex}].value`)];
+                });
+                return { type: 'map', entries };
+            }
+            default:
+                throw new SdPersistenceError('INVALID_NODE', `Unknown node type at index ${index}`);
+        }
+    }
+    #validateGraphValue(value, path) {
+        if (value === null || typeof value === 'boolean')
+            return value;
+        if (typeof value === 'string') {
+            this.#ensureStringLength(value, path);
+            return value;
+        }
+        if (typeof value === 'number') {
+            if (!Number.isFinite(value))
+                throw new SdPersistenceError('INVALID_DOCUMENT', `Non-finite number at ${path}`);
+            return value;
+        }
+        if (!this.#isRecord(value))
+            throw new SdPersistenceError('INVALID_DOCUMENT', `Invalid graph value at ${path}`);
+        const hasReference = '$ref' in value;
+        const hasType = '$type' in value;
+        if (hasReference === hasType)
+            throw new SdPersistenceError('INVALID_DOCUMENT', `Ambiguous graph value tag at ${path}`);
+        if (hasReference) {
+            if (!this.#hasExactKeys(value, ['$ref']))
+                throw new SdPersistenceError('INVALID_DOCUMENT', `Malformed reference tag at ${path}`);
+            if (!Number.isInteger(value['$ref']) || value['$ref'] < 0) {
+                throw new SdPersistenceError('INVALID_REFERENCE', `Invalid reference at ${path}`);
+            }
+            return { $ref: value['$ref'] };
+        }
+        if (value['$type'] === 'undefined' && this.#hasExactKeys(value, ['$type']))
+            return { $type: 'undefined' };
+        if (value['$type'] === 'number' && this.#hasExactKeys(value, ['$type', 'value']) && this.#isSpecialNumber(value['value'])) {
+            return { $type: 'number', value: value['value'] };
+        }
+        if (value['$type'] === 'bigint' &&
+            this.#hasExactKeys(value, ['$type', 'value']) &&
+            typeof value['value'] === 'string' &&
+            /^-?\d+$/.test(value['value'])) {
+            this.#ensureBigIntLength(value['value'], path);
+            return { $type: 'bigint', value: value['value'] };
+        }
+        throw new SdPersistenceError('INVALID_DOCUMENT', `Unknown graph value tag at ${path}`);
+    }
+    #validateDepth(envelope) {
+        const highestDepth = new Map();
+        const visit = (value, depth, path, active) => {
+            this.#ensureDepth(depth, path);
+            if (typeof value !== 'object' || value === null || !('$ref' in value))
+                return;
+            if (value.$ref >= envelope.nodes.length) {
+                throw new SdPersistenceError('INVALID_REFERENCE', `Reference out of bounds at ${path}`);
+            }
+            if (active.has(value.$ref))
+                return;
+            const previous = highestDepth.get(value.$ref);
+            if (previous !== undefined && previous >= depth)
+                return;
+            highestDepth.set(value.$ref, depth);
+            active.add(value.$ref);
+            const node = envelope.nodes[value.$ref];
+            switch (node.type) {
+                case 'array':
+                case 'set':
+                    node.values.forEach((item, index) => visit(item, depth + 1, `${path}[${index}]`, active));
+                    break;
+                case 'object':
+                    node.entries.forEach(([key, item]) => visit(item, depth + 1, `${path}.${key}`, active));
+                    break;
+                case 'map':
+                    node.entries.forEach(([key, item], index) => {
+                        visit(key, depth + 1, `${path}.mapKey[${index}]`, active);
+                        visit(item, depth + 1, `${path}.mapValue[${index}]`, active);
+                    });
+                    break;
+                case 'date':
+                    break;
+            }
+            active.delete(value.$ref);
+        };
+        visit(envelope.root, 0, '$.root', new Set());
+        envelope.nodes.forEach((_node, index) => visit({ $ref: index }, 0, `$.nodes[${index}]`, new Set()));
+    }
+    #createNode(node, index) {
+        switch (node.type) {
+            case 'array':
+                return [];
+            case 'object':
+                return node.prototype === 'null' ? Object.create(null) : {};
+            case 'date':
+                return new Date(node.value);
+            case 'map':
+                return new Map();
+            case 'set':
+                return new Set();
+            default:
+                throw new SdPersistenceError('INVALID_NODE', `Unknown node type at index ${index}`);
+        }
+    }
+    #populateNode(node, target, values) {
+        switch (node.type) {
+            case 'array': {
+                const array = target;
+                array.length = node.values.length;
+                node.values.forEach((value, index) => {
+                    array[index] = this.#decode(value, values, `array[${index}]`);
+                });
+                break;
+            }
+            case 'object': {
+                const object = target;
+                for (const [key, value] of node.entries) {
+                    Object.defineProperty(object, key, {
+                        configurable: true,
+                        enumerable: true,
+                        value: this.#decode(value, values, `object.${key}`),
+                        writable: true,
+                    });
+                }
+                break;
+            }
+            case 'map': {
+                const map = target;
+                for (const [key, value] of node.entries) {
+                    MAP_SET.call(map, this.#decode(key, values, 'map.key'), this.#decode(value, values, 'map.value'));
+                }
+                break;
+            }
+            case 'set': {
+                const set = target;
+                for (const value of node.values)
+                    SET_ADD.call(set, this.#decode(value, values, 'set.value'));
+                break;
+            }
+            case 'date':
+                break;
+        }
+    }
+    #decode(value, values, path) {
+        if (value === null || typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number')
+            return value;
+        if ('$ref' in value) {
+            if (value.$ref >= values.length)
+                throw new SdPersistenceError('INVALID_REFERENCE', `Reference out of bounds at ${path}`);
+            return values[value.$ref];
+        }
+        if (value.$type === 'undefined')
+            return undefined;
+        if (value.$type === 'bigint')
+            return BigInt(value.value);
+        switch (value.value) {
+            case 'NaN':
+                return Number.NaN;
+            case 'Infinity':
+                return Number.POSITIVE_INFINITY;
+            case '-Infinity':
+                return Number.NEGATIVE_INFINITY;
+            case '-0':
+                return -0;
+        }
+    }
+    #addNode(nodes, node, path) {
+        if (nodes.length >= this.limits.maxNodes)
+            throw new SdPersistenceError('LIMIT_EXCEEDED', `Graph node limit exceeded at ${path}`);
+        nodes.push(node);
+    }
+    #consumeEntries(count, path, budget) {
+        if (count > this.limits.maxEntries - budget.entries) {
+            throw new SdPersistenceError('LIMIT_EXCEEDED', `Graph entry limit exceeded at ${path}`);
+        }
+        budget.entries += count;
+    }
+    #ensureDocumentLength(length) {
+        if (length > this.limits.maxDocumentCharacters) {
+            throw new SdPersistenceError('LIMIT_EXCEEDED', 'Serialized document character limit exceeded');
+        }
+    }
+    #ensureDepth(depth, path) {
+        if (depth > this.limits.maxDepth)
+            throw new SdPersistenceError('LIMIT_EXCEEDED', `Graph depth limit exceeded at ${path}`);
+    }
+    #ensureStringLength(value, path) {
+        if (value.length > this.limits.maxStringCharacters) {
+            throw new SdPersistenceError('LIMIT_EXCEEDED', `String character limit exceeded at ${path}`);
+        }
+    }
+    #ensureKeyLength(value, path) {
+        if (value.length > this.limits.maxKeyCharacters) {
+            throw new SdPersistenceError('LIMIT_EXCEEDED', `Object key character limit exceeded at ${path}`);
+        }
+    }
+    #ensureBigIntLength(value, path) {
+        const digits = value.startsWith('-') ? value.length - 1 : value.length;
+        if (digits > this.limits.maxBigIntDigits) {
+            throw new SdPersistenceError('LIMIT_EXCEEDED', `BigInt digit limit exceeded at ${path}`);
+        }
+    }
+    #ensureNoOwnProperties(value, path, type) {
+        if (Reflect.ownKeys(value).length > 0) {
+            throw new SdPersistenceError('UNSUPPORTED_VALUE', `Own properties on ${type} are unsupported at ${path}`);
+        }
+    }
+    #rejectDuplicateValues(values, description) {
+        const seen = new Set();
+        values.forEach((value, index) => {
+            const signature = this.#graphValueSignature(value);
+            if (seen.has(signature))
+                throw new SdPersistenceError('INVALID_NODE', `Duplicate value in ${description}:${index}`);
+            seen.add(signature);
+        });
+    }
+    #graphValueSignature(value) {
+        if (value === null)
+            return 'null';
+        if (typeof value === 'string')
+            return `string:${value}`;
+        if (typeof value === 'boolean')
+            return `boolean:${value}`;
+        if (typeof value === 'number')
+            return `number:${Object.is(value, -0) ? 0 : value}`;
+        if ('$ref' in value)
+            return `ref:${value.$ref}`;
+        if (value.$type === 'number')
+            return value.value === '-0' ? 'number:0' : `number:${value.value}`;
+        if (value.$type === 'bigint')
+            return `bigint:${BigInt(value.value).toString()}`;
+        return `type:${value.$type}`;
+    }
+    #isArrayIndex(key, length) {
+        const index = Number(key);
+        return Number.isInteger(index) && index >= 0 && index < length && index <= 4_294_967_294 && String(index) === key;
+    }
+    #isSpecialNumber(value) {
+        return value === 'NaN' || value === 'Infinity' || value === '-Infinity' || value === '-0';
+    }
+    #hasExactKeys(value, expected) {
+        const keys = Object.keys(value);
+        return keys.length === expected.length && expected.every(key => Object.prototype.hasOwnProperty.call(value, key));
+    }
+    #isRecord(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+}
+
+class SdBrowserStorageAdapter {
+    #document = inject(DOCUMENT);
+    #platformId = inject(PLATFORM_ID);
+    readItem(area, key) {
+        try {
+            const storage = this.#getStorage(area);
+            if (!storage)
+                return { status: 'unavailable' };
+            const value = storage.getItem(key);
+            return value === null ? { status: 'absent' } : { status: 'found', value };
+        }
+        catch {
+            return { status: 'unavailable' };
+        }
+    }
+    getItem(area, key) {
+        const result = this.readItem(area, key);
+        return result.status === 'found' ? result.value : null;
+    }
+    setItem(area, key, value) {
+        try {
+            const storage = this.#getStorage(area);
+            if (!storage)
+                return false;
+            storage.setItem(key, value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    removeItem(area, key) {
+        try {
+            const storage = this.#getStorage(area);
+            if (!storage)
+                return false;
+            storage.removeItem(key);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    #getStorage(area) {
+        if (!isPlatformBrowser(this.#platformId))
+            return null;
+        const browserWindow = this.#document.defaultView;
+        if (!browserWindow)
+            return null;
+        return area === 'local' ? browserWindow.localStorage : browserWindow.sessionStorage;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: SdBrowserStorageAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: SdBrowserStorageAdapter, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: SdBrowserStorageAdapter, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+function readSdPersistenceStorageItem(adapter, area, key) {
+    try {
+        if (adapter.readItem)
+            return adapter.readItem(area, key);
+        const value = adapter.getItem(area, key);
+        return value === null ? { status: 'absent' } : { status: 'found', value };
+    }
+    catch {
+        return { status: 'unavailable' };
+    }
+}
+const SD_PERSISTENCE_STORAGE_ADAPTER = new InjectionToken('sd-persistence.storage-adapter', {
+    factory: () => inject(SdBrowserStorageAdapter),
+});
+
+class SdPersistenceIdentityError extends Error {
+    name = 'SdPersistenceIdentityError';
+    constructor(message) {
+        super(message);
+    }
+}
+function buildSdPersistenceKey(baseKey, fields) {
+    const parts = [{ tag: 'base', value: baseKey }, ...fields];
+    return `sdcorejs.persistence-key@1|${parts.map(part => `${encode(part.tag)}${encode(part.value)}`).join('|')}`;
+}
+class SdGraphIdentityCanonicalizer {
+    format = 'sdcorejs.graph-identity@1';
+    #serializer = new SdGraphSerializer();
+    canonicalize(value) {
+        return this.#serializer.stringify(value);
+    }
+}
+function canonicalizeSdPersistenceValue(canonicalizer, value, label) {
+    try {
+        return canonicalizer.canonicalize(value);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : 'unknown serialization error';
+        throw new SdPersistenceIdentityError(`Cannot canonicalize ${label}: ${detail}`);
+    }
+}
+function encode(value) {
+    return `${value.length}:${value}`;
+}
+function digestSdPersistenceKey(value) {
+    const bytes = encodeUtf8(value);
+    const bitLength = bytes.length * 8;
+    const paddedLength = Math.ceil((bytes.length + 9) / 64) * 64;
+    const padded = new Uint8Array(paddedLength);
+    padded.set(bytes);
+    padded[bytes.length] = 0x80;
+    const high = Math.floor(bitLength / 0x1_0000_0000);
+    const low = bitLength >>> 0;
+    writeUint32(padded, paddedLength - 8, high);
+    writeUint32(padded, paddedLength - 4, low);
+    const hash = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
+    const schedule = new Uint32Array(64);
+    for (let offset = 0; offset < padded.length; offset += 64) {
+        for (let index = 0; index < 16; index += 1) {
+            const position = offset + index * 4;
+            schedule[index] =
+                ((padded[position] ?? 0) << 24) |
+                    ((padded[position + 1] ?? 0) << 16) |
+                    ((padded[position + 2] ?? 0) << 8) |
+                    (padded[position + 3] ?? 0);
+        }
+        for (let index = 16; index < 64; index += 1) {
+            const previous15 = schedule[index - 15] ?? 0;
+            const previous2 = schedule[index - 2] ?? 0;
+            const sigma0 = rotateRight(previous15, 7) ^ rotateRight(previous15, 18) ^ (previous15 >>> 3);
+            const sigma1 = rotateRight(previous2, 17) ^ rotateRight(previous2, 19) ^ (previous2 >>> 10);
+            schedule[index] = ((schedule[index - 16] ?? 0) + sigma0 + (schedule[index - 7] ?? 0) + sigma1) >>> 0;
+        }
+        let a = hash[0] ?? 0;
+        let b = hash[1] ?? 0;
+        let c = hash[2] ?? 0;
+        let d = hash[3] ?? 0;
+        let e = hash[4] ?? 0;
+        let f = hash[5] ?? 0;
+        let g = hash[6] ?? 0;
+        let h = hash[7] ?? 0;
+        for (let index = 0; index < 64; index += 1) {
+            const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+            const choice = (e & f) ^ (~e & g);
+            const temp1 = (h + sum1 + choice + SHA256_CONSTANTS[index] + schedule[index]) >>> 0;
+            const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+            const majority = (a & b) ^ (a & c) ^ (b & c);
+            const temp2 = (sum0 + majority) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + temp1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temp1 + temp2) >>> 0;
+        }
+        hash[0] = (hash[0] + a) >>> 0;
+        hash[1] = (hash[1] + b) >>> 0;
+        hash[2] = (hash[2] + c) >>> 0;
+        hash[3] = (hash[3] + d) >>> 0;
+        hash[4] = (hash[4] + e) >>> 0;
+        hash[5] = (hash[5] + f) >>> 0;
+        hash[6] = (hash[6] + g) >>> 0;
+        hash[7] = (hash[7] + h) >>> 0;
+    }
+    return Array.from(hash, word => word.toString(16).padStart(8, '0')).join('');
+}
+const SHA256_CONSTANTS = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be,
+    0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa,
+    0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85,
+    0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+    0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,
+    0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+function encodeUtf8(value) {
+    const bytes = [];
+    for (let index = 0; index < value.length; index += 1) {
+        const first = value.charCodeAt(index);
+        let codePoint = first;
+        if (first >= 0xd800 && first <= 0xdbff && index + 1 < value.length) {
+            const second = value.charCodeAt(index + 1);
+            if (second >= 0xdc00 && second <= 0xdfff) {
+                codePoint = 0x10000 + ((first - 0xd800) << 10) + (second - 0xdc00);
+                index += 1;
+            }
+        }
+        if (codePoint <= 0x7f)
+            bytes.push(codePoint);
+        else if (codePoint <= 0x7ff)
+            bytes.push(0xc0 | (codePoint >>> 6), 0x80 | (codePoint & 0x3f));
+        else if (codePoint <= 0xffff) {
+            bytes.push(0xe0 | (codePoint >>> 12), 0x80 | ((codePoint >>> 6) & 0x3f), 0x80 | (codePoint & 0x3f));
+        }
+        else {
+            bytes.push(0xf0 | (codePoint >>> 18), 0x80 | ((codePoint >>> 12) & 0x3f), 0x80 | ((codePoint >>> 6) & 0x3f), 0x80 | (codePoint & 0x3f));
+        }
+    }
+    return Uint8Array.from(bytes);
+}
+function rotateRight(value, shift) {
+    return (value >>> shift) | (value << (32 - shift));
+}
+function writeUint32(target, offset, value) {
+    target[offset] = (value >>> 24) & 0xff;
+    target[offset + 1] = (value >>> 16) & 0xff;
+    target[offset + 2] = (value >>> 8) & 0xff;
+    target[offset + 3] = value & 0xff;
+}
+
+const SD_PERSISTENCE_ENVELOPE_FORMAT = 'sdcorejs.persistence-envelope';
+const SD_PERSISTENCE_ENVELOPE_VERSION = 1;
+const SD_PERSISTENCE_ENVELOPE_HARD_LIMITS = Object.freeze({
+    maxDocumentCharacters: 24_020_000,
+    maxPayloadCharacters: 4_000_000,
+    maxSerializerCharacters: 1_024,
+    maxIdentityCharacters: 1_024,
+});
+function stringifySdPersistenceValueEnvelope(identity, serializer, payload, limits) {
+    const resolved = resolveLimits(limits);
+    ensureFieldLimits(identity, serializer, payload, resolved);
+    const envelope = {
+        format: SD_PERSISTENCE_ENVELOPE_FORMAT,
+        version: SD_PERSISTENCE_ENVELOPE_VERSION,
+        kind: 'value',
+        identity,
+        serializer,
+        payload,
+    };
+    const serialized = JSON.stringify(envelope);
+    ensureDocumentLimit(serialized, resolved);
+    return serialized;
+}
+function stringifySdPersistenceTombstoneEnvelope(identity, serializer, limits) {
+    const resolved = resolveLimits(limits);
+    ensureFieldLimits(identity, serializer, undefined, resolved);
+    const envelope = {
+        format: SD_PERSISTENCE_ENVELOPE_FORMAT,
+        version: SD_PERSISTENCE_ENVELOPE_VERSION,
+        kind: 'tombstone',
+        identity,
+        serializer,
+    };
+    const serialized = JSON.stringify(envelope);
+    ensureDocumentLimit(serialized, resolved);
+    return serialized;
+}
+function parseSdPersistenceEnvelope(serialized, expectedIdentity, expectedSerializer, limits) {
+    const resolved = resolveLimits(limits);
+    ensureFieldLimits(expectedIdentity, expectedSerializer, undefined, resolved);
+    ensureDocumentLimit(serialized, resolved);
+    let value;
+    try {
+        value = JSON.parse(serialized);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(value))
+        return undefined;
+    if (typeof value['identity'] === 'string' && value['identity'].length > resolved.maxIdentityCharacters) {
+        throw new SdPersistenceError('LIMIT_EXCEEDED', 'Persistence envelope identity character limit exceeded');
+    }
+    if (typeof value['serializer'] === 'string' && value['serializer'].length > resolved.maxSerializerCharacters) {
+        throw new SdPersistenceError('LIMIT_EXCEEDED', 'Persistence envelope serializer character limit exceeded');
+    }
+    if (typeof value['payload'] === 'string' && value['payload'].length > resolved.maxPayloadCharacters) {
+        throw new SdPersistenceError('LIMIT_EXCEEDED', 'Persistence envelope payload character limit exceeded');
+    }
+    if (value['format'] !== SD_PERSISTENCE_ENVELOPE_FORMAT ||
+        value['version'] !== SD_PERSISTENCE_ENVELOPE_VERSION ||
+        value['identity'] !== expectedIdentity ||
+        value['serializer'] !== expectedSerializer) {
+        return undefined;
+    }
+    if (value['kind'] === 'tombstone' && hasExactKeys(value, ['format', 'version', 'kind', 'identity', 'serializer'])) {
+        return {
+            format: SD_PERSISTENCE_ENVELOPE_FORMAT,
+            version: SD_PERSISTENCE_ENVELOPE_VERSION,
+            kind: 'tombstone',
+            identity: expectedIdentity,
+            serializer: expectedSerializer,
+        };
+    }
+    if (value['kind'] === 'value' &&
+        typeof value['payload'] === 'string' &&
+        hasExactKeys(value, ['format', 'version', 'kind', 'identity', 'serializer', 'payload'])) {
+        return {
+            format: SD_PERSISTENCE_ENVELOPE_FORMAT,
+            version: SD_PERSISTENCE_ENVELOPE_VERSION,
+            kind: 'value',
+            identity: expectedIdentity,
+            serializer: expectedSerializer,
+            payload: value['payload'],
+        };
+    }
+    return undefined;
+}
+function resolveLimits(limits) {
+    const resolved = { ...SD_PERSISTENCE_ENVELOPE_HARD_LIMITS, ...limits };
+    for (const key of Object.keys(SD_PERSISTENCE_ENVELOPE_HARD_LIMITS)) {
+        const value = resolved[key];
+        if (!Number.isSafeInteger(value) || value < 1 || value > SD_PERSISTENCE_ENVELOPE_HARD_LIMITS[key]) {
+            throw new SdPersistenceError('LIMIT_EXCEEDED', `Invalid persistence envelope ${key} limit`);
+        }
+    }
+    return resolved;
+}
+function ensureFieldLimits(identity, serializer, payload, limits) {
+    if (identity.length > limits.maxIdentityCharacters) {
+        throw new SdPersistenceError('LIMIT_EXCEEDED', 'Persistence envelope identity character limit exceeded');
+    }
+    if (serializer.length > limits.maxSerializerCharacters) {
+        throw new SdPersistenceError('LIMIT_EXCEEDED', 'Persistence envelope serializer character limit exceeded');
+    }
+    if (payload !== undefined && payload.length > limits.maxPayloadCharacters) {
+        throw new SdPersistenceError('LIMIT_EXCEEDED', 'Persistence envelope payload character limit exceeded');
+    }
+}
+function ensureDocumentLimit(serialized, limits) {
+    if (serialized.length > limits.maxDocumentCharacters) {
+        throw new SdPersistenceError('LIMIT_EXCEEDED', 'Persistence envelope document character limit exceeded');
+    }
+}
+function hasExactKeys(value, expected) {
+    const keys = Object.keys(value);
+    return keys.length === expected.length && expected.every(key => Object.prototype.hasOwnProperty.call(value, key));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { SD_GRAPH_FORMAT, SD_GRAPH_HARD_LIMITS, SD_GRAPH_VERSION, SD_PERSISTENCE_ENVELOPE_FORMAT, SD_PERSISTENCE_ENVELOPE_HARD_LIMITS, SD_PERSISTENCE_ENVELOPE_VERSION, SD_PERSISTENCE_STORAGE_ADAPTER, SdBrowserStorageAdapter, SdGraphIdentityCanonicalizer, SdGraphSerializer, SdPersistenceError, SdPersistenceIdentityError, buildSdPersistenceKey, canonicalizeSdPersistenceValue, digestSdPersistenceKey, parseSdPersistenceEnvelope, readSdPersistenceStorageItem, stringifySdPersistenceTombstoneEnvelope, stringifySdPersistenceValueEnvelope };
+//# sourceMappingURL=sdcorejs-angular-services-persistence.mjs.map