@lossless.org/client 0.1.0

package/dist_ts/nosqldb/classes.collectiontopology.js

@@ -0,0 +1,388 @@
+import { SmartdataPersistenceError } from './classes.persistence.js';
+export const collectionModelSchemaResolverSymbol = Symbol('@push.rocks/smartdata.collectionModelSchemaResolver');
+export const collectionTopologyDbInspectionSymbol = Symbol('@push.rocks/smartdata.collectionTopologyDbInspection');
+const maximumCollectionIndexCount = 64;
+const maximumIndexKeyCount = 32;
+const fixedIdIndex = freezeIndex({
+    name: '_id_',
+    keys: [{ path: '_id', direction: 1, weight: null }],
+    unique: true,
+    sparse: false,
+    expireAfterSeconds: null,
+});
+const reasonCodeOrder = [
+    'namespace_not_collection',
+    'collection_options_present',
+    'id_index_missing',
+    'id_index_changed',
+    'expected_index_missing',
+    'unexpected_index',
+    'index_changed',
+    'unsupported_actual_index',
+];
+const ordinaryActualIndexKeys = new Set([
+    'v',
+    'key',
+    'name',
+    'ns',
+    'background',
+    'unique',
+    'sparse',
+    'expireAfterSeconds',
+]);
+const textActualIndexKeys = new Set([
+    ...ordinaryActualIndexKeys,
+    'weights',
+    'default_language',
+    'language_override',
+    'textIndexVersion',
+]);
+export const compareSmartdataTopologyStrings = (leftArg, rightArg) => {
+    const leftCodePoints = Array.from(leftArg, (characterArg) => characterArg.codePointAt(0));
+    const rightCodePoints = Array.from(rightArg, (characterArg) => characterArg.codePointAt(0));
+    const sharedLength = Math.min(leftCodePoints.length, rightCodePoints.length);
+    for (let index = 0; index < sharedLength; index++) {
+        if (leftCodePoints[index] !== rightCodePoints[index]) {
+            return leftCodePoints[index] < rightCodePoints[index] ? -1 : 1;
+        }
+    }
+    if (leftCodePoints.length === rightCodePoints.length) {
+        return 0;
+    }
+    return leftCodePoints.length < rightCodePoints.length ? -1 : 1;
+};
+function freezeIndex(indexArg) {
+    return Object.freeze({
+        name: indexArg.name,
+        keys: Object.freeze(indexArg.keys.map((keyArg) => Object.freeze({ ...keyArg }))),
+        unique: indexArg.unique,
+        sparse: indexArg.sparse,
+        expireAfterSeconds: indexArg.expireAfterSeconds,
+    });
+}
+const sortIndexes = (indexesArg) => Object.freeze([...indexesArg].sort((leftArg, rightArg) => compareSmartdataTopologyStrings(leftArg.name, rightArg.name)));
+const indexValuesEqual = (leftArg, rightArg) => JSON.stringify(leftArg) === JSON.stringify(rightArg);
+const getSchemaResolver = (constructorArg) => {
+    const resolver = constructorArg?.[collectionModelSchemaResolverSymbol];
+    if (typeof constructorArg !== 'function' ||
+        !Object.prototype.hasOwnProperty.call(constructorArg, collectionModelSchemaResolverSymbol) ||
+        typeof resolver !== 'function') {
+        throw new SmartdataPersistenceError('invalid_configuration', `Model "${constructorArg?.name || 'unknown'}" has no collection schema binding.`);
+    }
+    return resolver;
+};
+const normalizeExpectedIndex = (indexArg) => {
+    if (indexArg.name === '_id_') {
+        throw new SmartdataPersistenceError('invalid_configuration', 'Model index name "_id_" is reserved for MongoDB.');
+    }
+    if (indexArg.key.length > maximumIndexKeyCount) {
+        throw new SmartdataPersistenceError('invalid_configuration', `Index "${indexArg.name}" exceeds MongoDB's compound index field limit.`);
+    }
+    const expectedPhysicalKeyCount = indexArg.key.filter(([, directionArg]) => directionArg !== 'text').length +
+        (indexArg.key.some(([, directionArg]) => directionArg === 'text') ? 2 : 0);
+    if (expectedPhysicalKeyCount > maximumIndexKeyCount) {
+        throw new SmartdataPersistenceError('invalid_configuration', `Index "${indexArg.name}" exceeds MongoDB's physical compound index field limit.`);
+    }
+    const supportedOptions = new Set([
+        'background',
+        'unique',
+        'sparse',
+        'expireAfterSeconds',
+    ]);
+    for (const optionName of Object.keys(indexArg.options)) {
+        if (!supportedOptions.has(optionName)) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Index "${indexArg.name}" defines an unsupported topology option.`);
+        }
+    }
+    const textKeys = indexArg.key
+        .filter(([, directionArg]) => directionArg === 'text')
+        .map(([pathArg]) => pathArg)
+        .sort(compareSmartdataTopologyStrings);
+    const keys = [];
+    let emittedTextKeys = false;
+    for (const [path, direction] of indexArg.key) {
+        if (path === '_fts' || path === '_ftsx') {
+            throw new SmartdataPersistenceError('invalid_configuration', `Index "${indexArg.name}" uses a reserved MongoDB text-index field.`);
+        }
+        if (direction === 'text') {
+            if (!emittedTextKeys) {
+                keys.push(...textKeys.map((pathArg) => ({
+                    path: pathArg,
+                    direction: 'text',
+                    weight: 1,
+                })));
+                emittedTextKeys = true;
+            }
+            continue;
+        }
+        keys.push({ path, direction, weight: null });
+    }
+    return freezeIndex({
+        name: indexArg.name,
+        keys,
+        unique: indexArg.options.unique === true,
+        sparse: indexArg.options.sparse === true,
+        expireAfterSeconds: indexArg.options.expireAfterSeconds ?? null,
+    });
+};
+export const getExpectedCollectionTopologyForModel = (constructorArg) => {
+    const schema = getSchemaResolver(constructorArg)();
+    return getExpectedCollectionTopologyForSchema(schema);
+};
+/** @internal Normalizes the same contract for a bound collection. */
+export const getExpectedCollectionTopologyForSchema = (schema) => {
+    if (schema.indexes.length + 1 > maximumCollectionIndexCount) {
+        throw new SmartdataPersistenceError('invalid_configuration', `Collection "${schema.collectionName}" exceeds MongoDB's collection index limit.`);
+    }
+    const indexes = sortIndexes([
+        fixedIdIndex,
+        ...schema.indexes.map((indexArg) => normalizeExpectedIndex(indexArg)),
+    ]);
+    return Object.freeze({
+        collectionName: schema.collectionName,
+        indexes,
+    });
+};
+const normalizeActualIndex = (rawIndexArg) => {
+    if (typeof rawIndexArg !== 'object' ||
+        rawIndexArg === null ||
+        Array.isArray(rawIndexArg)) {
+        return { supported: false };
+    }
+    const rawIndex = rawIndexArg;
+    const name = typeof rawIndex.name === 'string' ? rawIndex.name : undefined;
+    if (!name || typeof rawIndex.key !== 'object' || rawIndex.key === null) {
+        return { name, supported: false };
+    }
+    const allRawKeyEntries = Object.entries(rawIndex.key);
+    const maximumPhysicalKeyCount = maximumIndexKeyCount;
+    const rawKeyEntries = allRawKeyEntries.slice(0, maximumPhysicalKeyCount);
+    if (rawKeyEntries.length === 0) {
+        return { name, supported: false };
+    }
+    const textMarkerIndex = rawKeyEntries.findIndex(([pathArg, directionArg]) => pathArg === '_fts' && directionArg === 'text');
+    const hasTextMarker = textMarkerIndex !== -1;
+    let supported = Reflect.ownKeys(rawIndex).every((keyArg) => typeof keyArg === 'string' &&
+        (hasTextMarker ? textActualIndexKeys : ordinaryActualIndexKeys).has(keyArg));
+    if (allRawKeyEntries.length > maximumPhysicalKeyCount ||
+        rawKeyEntries.some(([pathArg]) => pathArg === '$**' || pathArg.endsWith('.$**'))) {
+        supported = false;
+    }
+    if (rawIndex.background !== undefined &&
+        typeof rawIndex.background !== 'boolean') {
+        supported = false;
+    }
+    if (rawIndex.unique !== undefined && typeof rawIndex.unique !== 'boolean') {
+        supported = false;
+    }
+    if (rawIndex.sparse !== undefined && typeof rawIndex.sparse !== 'boolean') {
+        supported = false;
+    }
+    const expireAfterSeconds = rawIndex.expireAfterSeconds;
+    if (expireAfterSeconds !== undefined &&
+        (typeof expireAfterSeconds !== 'number' ||
+            !Number.isFinite(expireAfterSeconds) ||
+            expireAfterSeconds < 0)) {
+        supported = false;
+    }
+    let textWeights = new Map();
+    if (hasTextMarker) {
+        if (rawKeyEntries.filter(([pathArg]) => pathArg === '_fts').length !== 1 ||
+            rawKeyEntries[textMarkerIndex + 1]?.[0] !== '_ftsx' ||
+            rawKeyEntries[textMarkerIndex + 1]?.[1] !== 1 ||
+            typeof rawIndex.weights !== 'object' ||
+            rawIndex.weights === null ||
+            Array.isArray(rawIndex.weights)) {
+            supported = false;
+        }
+        else {
+            const rawWeightEntries = Object.entries(rawIndex.weights);
+            if (rawWeightEntries.length > maximumIndexKeyCount) {
+                supported = false;
+            }
+            textWeights = new Map(rawWeightEntries
+                .sort(([leftArg], [rightArg]) => compareSmartdataTopologyStrings(leftArg, rightArg))
+                .slice(0, maximumIndexKeyCount)
+                .flatMap(([pathArg, weightArg]) => {
+                if (typeof weightArg !== 'number' ||
+                    !Number.isFinite(weightArg) ||
+                    weightArg <= 0) {
+                    supported = false;
+                    return [];
+                }
+                return [[pathArg, weightArg]];
+            }));
+            if (textWeights.size === 0) {
+                supported = false;
+            }
+        }
+        if ((rawIndex.default_language !== undefined &&
+            rawIndex.default_language !== 'english') ||
+            (rawIndex.language_override !== undefined &&
+                rawIndex.language_override !== 'language') ||
+            (rawIndex.textIndexVersion !== undefined &&
+                rawIndex.textIndexVersion !== 3)) {
+            supported = false;
+        }
+    }
+    const keys = [];
+    for (let index = 0; index < rawKeyEntries.length; index++) {
+        const [path, direction] = rawKeyEntries[index];
+        if (hasTextMarker && index === textMarkerIndex) {
+            keys.push(...[...textWeights].map(([pathArg, weightArg]) => ({
+                path: pathArg,
+                direction: 'text',
+                weight: weightArg,
+            })));
+            index++;
+            continue;
+        }
+        if (direction !== 1 && direction !== -1) {
+            supported = false;
+            continue;
+        }
+        keys.push({ path, direction, weight: null });
+    }
+    if (keys.length > maximumIndexKeyCount) {
+        supported = false;
+        keys.length = maximumIndexKeyCount;
+    }
+    if (keys.length === 0) {
+        return { name, supported: false };
+    }
+    let normalized = freezeIndex({
+        name,
+        keys,
+        unique: rawIndex.unique === true,
+        sparse: rawIndex.sparse === true,
+        expireAfterSeconds: typeof expireAfterSeconds === 'number' &&
+            Number.isFinite(expireAfterSeconds) &&
+            expireAfterSeconds >= 0
+            ? expireAfterSeconds
+            : null,
+    });
+    if (name === '_id_' &&
+        normalized.keys.length === 1 &&
+        normalized.keys[0].path === '_id' &&
+        normalized.keys[0].direction === 1 &&
+        normalized.keys[0].weight === null &&
+        (rawIndex.unique === undefined || rawIndex.unique === true) &&
+        normalized.sparse === false &&
+        normalized.expireAfterSeconds === null) {
+        normalized = fixedIdIndex;
+    }
+    return { index: normalized, name, supported };
+};
+const buildReasonCodes = (reasonsArg) => Object.freeze(reasonCodeOrder.filter((reasonCodeArg) => reasonsArg.has(reasonCodeArg)));
+const createInspection = (expectedArg, statusArg, reasonsArg, actualIndexesArg) => Object.freeze({
+    collectionName: expectedArg.collectionName,
+    status: statusArg,
+    reasonCodes: buildReasonCodes(reasonsArg),
+    expectedIndexes: expectedArg.indexes,
+    actualIndexes: sortIndexes(actualIndexesArg),
+});
+export const inspectCollectionTopologyForModel = async (constructorArg, dbArg) => {
+    const expected = getExpectedCollectionTopologyForModel(constructorArg);
+    const inspectionHost = dbArg;
+    if (typeof inspectionHost?.[collectionTopologyDbInspectionSymbol] !== 'function') {
+        throw new SmartdataPersistenceError('invalid_argument', 'Collection topology inspection requires a SmartdataDb.');
+    }
+    const rawSnapshot = await inspectionHost[collectionTopologyDbInspectionSymbol](async (mongoDbArg) => {
+        const namespace = (await mongoDbArg
+            .listCollections({ name: expected.collectionName }, { nameOnly: false })
+            .next());
+        if (!namespace || namespace.type !== 'collection') {
+            return { namespace, indexes: [] };
+        }
+        const indexes = await mongoDbArg
+            .collection(expected.collectionName)
+            .listIndexes()
+            .toArray();
+        return { namespace, indexes };
+    });
+    return inspectCollectionTopologySnapshot(expected, rawSnapshot);
+};
+/** @internal Pure normalization shared by model and namespace inspection. */
+export const inspectCollectionTopologySnapshot = (expected, rawSnapshot) => {
+    if (!rawSnapshot.namespace) {
+        return createInspection(expected, 'absent', new Set(), []);
+    }
+    try {
+        const reasons = new Set();
+        const namespace = rawSnapshot.namespace;
+        if (namespace.name !== expected.collectionName ||
+            namespace.type !== 'collection') {
+            reasons.add('namespace_not_collection');
+        }
+        if (typeof namespace.options !== 'object' ||
+            namespace.options === null ||
+            Array.isArray(namespace.options) ||
+            Reflect.ownKeys(namespace.options).length !== 0) {
+            reasons.add('collection_options_present');
+        }
+        const rawIndexes = rawSnapshot.indexes.slice(0, maximumCollectionIndexCount);
+        if (rawSnapshot.indexes.length > maximumCollectionIndexCount) {
+            reasons.add('unsupported_actual_index');
+        }
+        const normalizedIndexes = [];
+        const unsupportedNames = new Set();
+        for (const rawIndex of rawIndexes) {
+            const normalized = normalizeActualIndex(rawIndex);
+            if (!normalized.supported) {
+                reasons.add('unsupported_actual_index');
+                if (normalized.name) {
+                    unsupportedNames.add(normalized.name);
+                }
+            }
+            if (normalized.index) {
+                normalizedIndexes.push(normalized.index);
+            }
+        }
+        const actualByName = new Map();
+        for (const actualIndex of normalizedIndexes) {
+            if (actualByName.has(actualIndex.name)) {
+                reasons.add('unsupported_actual_index');
+                continue;
+            }
+            actualByName.set(actualIndex.name, actualIndex);
+        }
+        const expectedByName = new Map(expected.indexes.map((indexArg) => [indexArg.name, indexArg]));
+        const actualIdIndex = actualByName.get('_id_');
+        if (!actualIdIndex && !unsupportedNames.has('_id_')) {
+            reasons.add('id_index_missing');
+        }
+        else if (actualIdIndex &&
+            !indexValuesEqual(actualIdIndex, fixedIdIndex)) {
+            reasons.add('id_index_changed');
+        }
+        for (const expectedIndex of expected.indexes) {
+            if (expectedIndex.name === '_id_') {
+                continue;
+            }
+            const actualIndex = actualByName.get(expectedIndex.name);
+            if (!actualIndex) {
+                if (!unsupportedNames.has(expectedIndex.name)) {
+                    reasons.add('expected_index_missing');
+                }
+            }
+            else if (!indexValuesEqual(expectedIndex, actualIndex)) {
+                reasons.add('index_changed');
+            }
+        }
+        for (const actualIndex of actualByName.values()) {
+            if (!expectedByName.has(actualIndex.name)) {
+                reasons.add('unexpected_index');
+            }
+        }
+        const status = reasons.size === 0
+            ? 'exact'
+            : [...reasons].every((reasonArg) => reasonArg === 'expected_index_missing')
+                ? 'compatible'
+                : 'divergent';
+        return createInspection(expected, status, reasons, normalizedIndexes);
+    }
+    catch {
+        throw new SmartdataPersistenceError('unsupported_operation', 'Collection topology inspection returned unreadable metadata.');
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.collectiontopology.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.collectiontopology.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAiDrE,MAAM,CAAC,MAAM,mCAAmC,GAAG,MAAM,CACvD,qDAAqD,CACtD,CAAC;AAEF,MAAM,CAAC,MAAM,oCAAoC,GAAG,MAAM,CACxD,sDAAsD,CACvD,CAAC;AAkBF,MAAM,2BAA2B,GAAG,EAAE,CAAC;AACvC,MAAM,oBAAoB,GAAG,EAAE,CAAC;AAChC,MAAM,YAAY,GAAG,WAAW,CAAC;IAC/B,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IACnD,MAAM,EAAE,IAAI;IACZ,MAAM,EAAE,KAAK;IACb,kBAAkB,EAAE,IAAI;CACzB,CAAC,CAAC;AACH,MAAM,eAAe,GAAsD;IACzE,0BAA0B;IAC1B,4BAA4B;IAC5B,kBAAkB;IAClB,kBAAkB;IAClB,wBAAwB;IACxB,kBAAkB;IAClB,eAAe;IACf,0BAA0B;CAC3B,CAAC;AACF,MAAM,uBAAuB,GAAG,IAAI,GAAG,CAAC;IACtC,GAAG;IACH,KAAK;IACL,MAAM;IACN,IAAI;IACJ,YAAY;IACZ,QAAQ;IACR,QAAQ;IACR,oBAAoB;CACrB,CAAC,CAAC;AACH,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC;IAClC,GAAG,uBAAuB;IAC1B,SAAS;IACT,kBAAkB;IAClB,mBAAmB;IACnB,kBAAkB;CACnB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAC7C,OAAe,EACf,QAAgB,EACR,EAAE;IACV,MAAM,cAAc,GAAG,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,YAAY,EAAE,EAAE,CAC1D,YAAY,CAAC,WAAW,CAAC,CAAC,CAAE,CAC7B,CAAC;IACF,MAAM,eAAe,GAAG,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,YAAY,EAAE,EAAE,CAC5D,YAAY,CAAC,WAAW,CAAC,CAAC,CAAE,CAC7B,CAAC;IACF,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IAC7E,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,YAAY,EAAE,KAAK,EAAE,EAAE,CAAC;QAClD,IAAI,cAAc,CAAC,KAAK,CAAC,KAAK,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;YACrD,OAAO,cAAc,CAAC,KAAK,CAAC,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjE,CAAC;IACH,CAAC;IACD,IAAI,cAAc,CAAC,MAAM,KAAK,eAAe,CAAC,MAAM,EAAE,CAAC;QACrD,OAAO,CAAC,CAAC;IACX,CAAC;IACD,OAAO,cAAc,CAAC,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACjE,CAAC,CAAC;AAEF,SAAS,WAAW,CAClB,QAUC;IAED,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,IAAI,EAAE,MAAM,CAAC,MAAM,CACjB,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC,CAC5D;QACD,MAAM,EAAE,QAAQ,CAAC,MAAM;QACvB,MAAM,EAAE,QAAQ,CAAC,MAAM;QACvB,kBAAkB,EAAE,QAAQ,CAAC,kBAAkB;KAChD,CAAC,CAAC;AACL,CAAC;AAED,MAAM,WAAW,GAAG,CAClB,UAAwD,EACV,EAAE,CAChD,MAAM,CAAC,MAAM,CACX,CAAC,GAAG,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,EAAE,CACzC,+BAA+B,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,CAC7D,CACF,CAAC;AAEJ,MAAM,gBAAgB,GAAG,CACvB,OAA0C,EAC1C,QAA2C,EAClC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;AAEnE,MAAM,iBAAiB,GAAG,CACxB,cAAmD,EACnB,EAAE;IAClC,MAAM,QAAQ,GAAG,cAAc,EAAE,CAAC,mCAAmC,CAAC,CAAC;IACvE,IACE,OAAO,cAAc,KAAK,UAAU;QACpC,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CACnC,cAAc,EACd,mCAAmC,CACpC;QACD,OAAO,QAAQ,KAAK,UAAU,EAC9B,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,UAAU,cAAc,EAAE,IAAI,IAAI,SAAS,qCAAqC,CACjF,CAAC;IACJ,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,sBAAsB,GAAG,CAC7B,QAA6D,EAC1B,EAAE;IACrC,IAAI,QAAQ,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;QAC7B,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,kDAAkD,CACnD,CAAC;IACJ,CAAC;IACD,IAAI,QAAQ,CAAC,GAAG,CAAC,MAAM,GAAG,oBAAoB,EAAE,CAAC;QAC/C,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,UAAU,QAAQ,CAAC,IAAI,iDAAiD,CACzE,CAAC;IACJ,CAAC;IACD,MAAM,wBAAwB,GAC5B,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,EAAE,CAAC,YAAY,KAAK,MAAM,CAAC,CAAC,MAAM;QACzE,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,EAAE,CAAC,YAAY,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7E,IAAI,wBAAwB,GAAG,oBAAoB,EAAE,CAAC;QACpD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,UAAU,QAAQ,CAAC,IAAI,0DAA0D,CAClF,CAAC;IACJ,CAAC;IACD,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC;QAC/B,YAAY;QACZ,QAAQ;QACR,QAAQ;QACR,oBAAoB;KACrB,CAAC,CAAC;IACH,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACvD,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;YACtC,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,UAAU,QAAQ,CAAC,IAAI,2CAA2C,CACnE,CAAC;QACJ,CAAC;IACH,CAAC;IAED,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG;SAC1B,MAAM,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,EAAE,CAAC,YAAY,KAAK,MAAM,CAAC;SACrD,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC;SAC3B,IAAI,CAAC,+BAA+B,CAAC,CAAC;IACzC,MAAM,IAAI,GAIL,EAAE,CAAC;IACR,IAAI,eAAe,GAAG,KAAK,CAAC;IAC5B,KAAK,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,QAAQ,CAAC,GAAG,EAAE,CAAC;QAC7C,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;YACxC,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,UAAU,QAAQ,CAAC,IAAI,6CAA6C,CACrE,CAAC;QACJ,CAAC;QACD,IAAI,SAAS,KAAK,MAAM,EAAE,CAAC;YACzB,IAAI,CAAC,eAAe,EAAE,CAAC;gBACrB,IAAI,CAAC,IAAI,CACP,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;oBAC5B,IAAI,EAAE,OAAO;oBACb,SAAS,EAAE,MAAe;oBAC1B,MAAM,EAAE,CAAC;iBACV,CAAC,CAAC,CACJ,CAAC;gBACF,eAAe,GAAG,IAAI,CAAC;YACzB,CAAC;YACD,SAAS;QACX,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,WAAW,CAAC;QACjB,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,IAAI;QACJ,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,KAAK,IAAI;QACxC,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,KAAK,IAAI;QACxC,kBAAkB,EAAE,QAAQ,CAAC,OAAO,CAAC,kBAAkB,IAAI,IAAI;KAChE,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,qCAAqC,GAAG,CACnD,cAAmD,EACb,EAAE;IACxC,MAAM,MAAM,GAAG,iBAAiB,CAAC,cAAc,CAAC,EAAE,CAAC;IACnD,OAAO,sCAAsC,CAAC,MAAM,CAAC,CAAC;AACxD,CAAC,CAAC;AAEF,qEAAqE;AACrE,MAAM,CAAC,MAAM,sCAAsC,GAAG,CACpD,MAAwC,EACF,EAAE;IACxC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,GAAG,2BAA2B,EAAE,CAAC;QAC5D,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,eAAe,MAAM,CAAC,cAAc,6CAA6C,CAClF,CAAC;IACJ,CAAC;IACD,MAAM,OAAO,GAAG,WAAW,CAAC;QAC1B,YAAY;QACZ,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,sBAAsB,CAAC,QAAQ,CAAC,CAAC;KACtE,CAAC,CAAC;IACH,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,cAAc,EAAE,MAAM,CAAC,cAAc;QACrC,OAAO;KACR,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,oBAAoB,GAAG,CAC3B,WAAoB,EACO,EAAE;IAC7B,IACE,OAAO,WAAW,KAAK,QAAQ;QAC/B,WAAW,KAAK,IAAI;QACpB,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAC1B,CAAC;QACD,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IAC9B,CAAC;IACD,MAAM,QAAQ,GAAG,WAAsC,CAAC;IACxD,MAAM,IAAI,GAAG,OAAO,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,IAAI,CAAC,IAAI,IAAI,OAAO,QAAQ,CAAC,GAAG,KAAK,QAAQ,IAAI,QAAQ,CAAC,GAAG,KAAK,IAAI,EAAE,CAAC;QACvE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IACpC,CAAC;IACD,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,CACrC,QAAQ,CAAC,GAA8B,CACxC,CAAC;IACF,MAAM,uBAAuB,GAAG,oBAAoB,CAAC;IACrD,MAAM,aAAa,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC,EAAE,uBAAuB,CAAC,CAAC;IACzE,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC/B,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IACpC,CAAC;IAED,MAAM,eAAe,GAAG,aAAa,CAAC,SAAS,CAC7C,CAAC,CAAC,OAAO,EAAE,YAAY,CAAC,EAAE,EAAE,CAC1B,OAAO,KAAK,MAAM,IAAI,YAAY,KAAK,MAAM,CAChD,CAAC;IACF,MAAM,aAAa,GAAG,eAAe,KAAK,CAAC,CAAC,CAAC;IAC7C,IAAI,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,KAAK,CAC7C,CAAC,MAAM,EAAE,EAAE,CACT,OAAO,MAAM,KAAK,QAAQ;QAC1B,CAAC,aAAa,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC,GAAG,CACjE,MAAM,CACP,CACJ,CAAC;IACF,IACE,gBAAgB,CAAC,MAAM,GAAG,uBAAuB;QACjD,aAAa,CAAC,IAAI,CAChB,CAAC,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,KAAK,KAAK,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAC7D,EACD,CAAC;QACD,SAAS,GAAG,KAAK,CAAC;IACpB,CAAC;IACD,IACE,QAAQ,CAAC,UAAU,KAAK,SAAS;QACjC,OAAO,QAAQ,CAAC,UAAU,KAAK,SAAS,EACxC,CAAC;QACD,SAAS,GAAG,KAAK,CAAC;IACpB,CAAC;IACD,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS,IAAI,OAAO,QAAQ,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC1E,SAAS,GAAG,KAAK,CAAC;IACpB,CAAC;IACD,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS,IAAI,OAAO,QAAQ,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC1E,SAAS,GAAG,KAAK,CAAC;IACpB,CAAC;IACD,MAAM,kBAAkB,GAAG,QAAQ,CAAC,kBAAkB,CAAC;IACvD,IACE,kBAAkB,KAAK,SAAS;QAChC,CAAC,OAAO,kBAAkB,KAAK,QAAQ;YACrC,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAC;YACpC,kBAAkB,GAAG,CAAC,CAAC,EACzB,CAAC;QACD,SAAS,GAAG,KAAK,CAAC;IACpB,CAAC;IAED,IAAI,WAAW,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC5C,IAAI,aAAa,EAAE,CAAC;QAClB,IACE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC;YACpE,aAAa,CAAC,eAAe,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,OAAO;YACnD,aAAa,CAAC,eAAe,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;YAC7C,OAAO,QAAQ,CAAC,OAAO,KAAK,QAAQ;YACpC,QAAQ,CAAC,OAAO,KAAK,IAAI;YACzB,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,EAC/B,CAAC;YACD,SAAS,GAAG,KAAK,CAAC;QACpB,CAAC;aAAM,CAAC;YACN,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,CACrC,QAAQ,CAAC,OAAkC,CAC5C,CAAC;YACF,IAAI,gBAAgB,CAAC,MAAM,GAAG,oBAAoB,EAAE,CAAC;gBACnD,SAAS,GAAG,KAAK,CAAC;YACpB,CAAC;YACD,WAAW,GAAG,IAAI,GAAG,CACnB,gBAAgB;iBACb,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,CAC9B,+BAA+B,CAAC,OAAO,EAAE,QAAQ,CAAC,CACnD;iBACA,KAAK,CAAC,CAAC,EAAE,oBAAoB,CAAC;iBAC9B,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,EAAE;gBAChC,IACE,OAAO,SAAS,KAAK,QAAQ;oBAC7B,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC;oBAC3B,SAAS,IAAI,CAAC,EACd,CAAC;oBACD,SAAS,GAAG,KAAK,CAAC;oBAClB,OAAO,EAAE,CAAC;gBACZ,CAAC;gBACD,OAAO,CAAC,CAAC,OAAO,EAAE,SAAS,CAAU,CAAC,CAAC;YACzC,CAAC,CAAC,CACL,CAAC;YACF,IAAI,WAAW,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;gBAC3B,SAAS,GAAG,KAAK,CAAC;YACpB,CAAC;QACH,CAAC;QACD,IACE,CAAC,QAAQ,CAAC,gBAAgB,KAAK,SAAS;YACtC,QAAQ,CAAC,gBAAgB,KAAK,SAAS,CAAC;YAC1C,CAAC,QAAQ,CAAC,iBAAiB,KAAK,SAAS;gBACvC,QAAQ,CAAC,iBAAiB,KAAK,UAAU,CAAC;YAC5C,CAAC,QAAQ,CAAC,gBAAgB,KAAK,SAAS;gBACtC,QAAQ,CAAC,gBAAgB,KAAK,CAAC,CAAC,EAClC,CAAC;YACD,SAAS,GAAG,KAAK,CAAC;QACpB,CAAC;IACH,CAAC;IAED,MAAM,IAAI,GAIL,EAAE,CAAC;IACR,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,aAAa,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QAC1D,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;QAC/C,IAAI,aAAa,IAAI,KAAK,KAAK,eAAe,EAAE,CAAC;YAC/C,IAAI,CAAC,IAAI,CACP,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC,CAAC;gBACjD,IAAI,EAAE,OAAO;gBACb,SAAS,EAAE,MAAe;gBAC1B,MAAM,EAAE,SAAS;aAClB,CAAC,CAAC,CACJ,CAAC;YACF,KAAK,EAAE,CAAC;YACR,SAAS;QACX,CAAC;QACD,IAAI,SAAS,KAAK,CAAC,IAAI,SAAS,KAAK,CAAC,CAAC,EAAE,CAAC;YACxC,SAAS,GAAG,KAAK,CAAC;YAClB,SAAS;QACX,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IAC/C,CAAC;IACD,IAAI,IAAI,CAAC,MAAM,GAAG,oBAAoB,EAAE,CAAC;QACvC,SAAS,GAAG,KAAK,CAAC;QAClB,IAAI,CAAC,MAAM,GAAG,oBAAoB,CAAC;IACrC,CAAC;IACD,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IACpC,CAAC;IAED,IAAI,UAAU,GAAG,WAAW,CAAC;QAC3B,IAAI;QACJ,IAAI;QACJ,MAAM,EAAE,QAAQ,CAAC,MAAM,KAAK,IAAI;QAChC,MAAM,EAAE,QAAQ,CAAC,MAAM,KAAK,IAAI;QAChC,kBAAkB,EAChB,OAAO,kBAAkB,KAAK,QAAQ;YACtC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAC;YACnC,kBAAkB,IAAI,CAAC;YACrB,CAAC,CAAC,kBAAkB;YACpB,CAAC,CAAC,IAAI;KACX,CAAC,CAAC;IACH,IACE,IAAI,KAAK,MAAM;QACf,UAAU,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;QAC5B,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,KAAK;QACjC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,KAAK,CAAC;QAClC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,IAAI;QAClC,CAAC,QAAQ,CAAC,MAAM,KAAK,SAAS,IAAI,QAAQ,CAAC,MAAM,KAAK,IAAI,CAAC;QAC3D,UAAU,CAAC,MAAM,KAAK,KAAK;QAC3B,UAAU,CAAC,kBAAkB,KAAK,IAAI,EACtC,CAAC;QACD,UAAU,GAAG,YAAY,CAAC;IAC5B,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;AAChD,CAAC,CAAC;AAEF,MAAM,gBAAgB,GAAG,CACvB,UAA+D,EACZ,EAAE,CACrD,MAAM,CAAC,MAAM,CACX,eAAe,CAAC,MAAM,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,CACzE,CAAC;AAEJ,MAAM,gBAAgB,GAAG,CACvB,WAAiD,EACjD,SAA6C,EAC7C,UAA+D,EAC/D,gBAA8D,EACtB,EAAE,CAC1C,MAAM,CAAC,MAAM,CAAC;IACZ,cAAc,EAAE,WAAW,CAAC,cAAc;IAC1C,MAAM,EAAE,SAAS;IACjB,WAAW,EAAE,gBAAgB,CAAC,UAAU,CAAC;IACzC,eAAe,EAAE,WAAW,CAAC,OAAO;IACpC,aAAa,EAAE,WAAW,CAAC,gBAAgB,CAAC;CAC7C,CAAC,CAAC;AAEL,MAAM,CAAC,MAAM,iCAAiC,GAAG,KAAK,EACpD,cAAmD,EACnD,KAAkB,EAC+B,EAAE;IACnD,MAAM,QAAQ,GAAG,qCAAqC,CAAC,cAAc,CAAC,CAAC;IACvE,MAAM,cAAc,GAAG,KAItB,CAAC;IACF,IACE,OAAO,cAAc,EAAE,CAAC,oCAAoC,CAAC,KAAK,UAAU,EAC5E,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,wDAAwD,CACzD,CAAC;IACJ,CAAC;IAED,MAAM,WAAW,GAAG,MAAM,cAAc,CAAC,oCAAoC,CAAC,CAC5E,KAAK,EAAE,UAAU,EAA2C,EAAE;QAC5D,MAAM,SAAS,GAAG,CAAC,MAAM,UAAU;aAChC,eAAe,CACd,EAAE,IAAI,EAAE,QAAQ,CAAC,cAAc,EAAE,EACjC,EAAE,QAAQ,EAAE,KAAK,EAAE,CACpB;aACA,IAAI,EAAE,CAAmC,CAAC;QAC7C,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;YAClD,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;QACpC,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,UAAU;aAC7B,UAAU,CAAC,QAAQ,CAAC,cAAc,CAAC;aACnC,WAAW,EAAE;aACb,OAAO,EAAE,CAAC;QACb,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;IAChC,CAAC,CACF,CAAC;IAEF,OAAO,iCAAiC,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;AAClE,CAAC,CAAC;AAEF,6EAA6E;AAC7E,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAC/C,QAA8C,EAC9C,WAA2C,EACH,EAAE;IAE1C,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC;QAC3B,OAAO,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC;IAC7D,CAAC;IAED,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,IAAI,GAAG,EAA0C,CAAC;QAClE,MAAM,SAAS,GAAG,WAAW,CAAC,SAAS,CAAC;QACxC,IACE,SAAS,CAAC,IAAI,KAAK,QAAQ,CAAC,cAAc;YAC1C,SAAS,CAAC,IAAI,KAAK,YAAY,EAC/B,CAAC;YACD,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;QAC1C,CAAC;QACD,IACE,OAAO,SAAS,CAAC,OAAO,KAAK,QAAQ;YACrC,SAAS,CAAC,OAAO,KAAK,IAAI;YAC1B,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC;YAChC,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,MAAM,KAAK,CAAC,EAC/C,CAAC;YACD,OAAO,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC;QAC5C,CAAC;QAED,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,CAAC,KAAK,CAC1C,CAAC,EACD,2BAA2B,CAC5B,CAAC;QACF,IAAI,WAAW,CAAC,OAAO,CAAC,MAAM,GAAG,2BAA2B,EAAE,CAAC;YAC7D,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;QAC1C,CAAC;QACD,MAAM,iBAAiB,GAAwC,EAAE,CAAC;QAClE,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAAU,CAAC;QAC3C,KAAK,MAAM,QAAQ,IAAI,UAAU,EAAE,CAAC;YAClC,MAAM,UAAU,GAAG,oBAAoB,CAAC,QAAQ,CAAC,CAAC;YAClD,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;gBAC1B,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;gBACxC,IAAI,UAAU,CAAC,IAAI,EAAE,CAAC;oBACpB,gBAAgB,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;gBACxC,CAAC;YACH,CAAC;YACD,IAAI,UAAU,CAAC,KAAK,EAAE,CAAC;gBACrB,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YAC3C,CAAC;QACH,CAAC;QAED,MAAM,YAAY,GAAG,IAAI,GAAG,EAA6C,CAAC;QAC1E,KAAK,MAAM,WAAW,IAAI,iBAAiB,EAAE,CAAC;YAC5C,IAAI,YAAY,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;gBACvC,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;gBACxC,SAAS;YACX,CAAC;YACD,YAAY,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QAClD,CAAC;QACD,MAAM,cAAc,GAAG,IAAI,GAAG,CAC5B,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAC9D,CAAC;QACF,MAAM,aAAa,GAAG,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC/C,IAAI,CAAC,aAAa,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;YACpD,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QAClC,CAAC;aAAM,IACL,aAAa;YACb,CAAC,gBAAgB,CAAC,aAAa,EAAE,YAAY,CAAC,EAC9C,CAAC;YACD,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QAClC,CAAC;QAED,KAAK,MAAM,aAAa,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;YAC7C,IAAI,aAAa,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;gBAClC,SAAS;YACX,CAAC;YACD,MAAM,WAAW,GAAG,YAAY,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;YACzD,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC;oBAC9C,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;gBACxC,CAAC;YACH,CAAC;iBAAM,IAAI,CAAC,gBAAgB,CAAC,aAAa,EAAE,WAAW,CAAC,EAAE,CAAC;gBACzD,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;YAC/B,CAAC;QACH,CAAC;QACD,KAAK,MAAM,WAAW,IAAI,YAAY,CAAC,MAAM,EAAE,EAAE,CAAC;YAChD,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC1C,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;YAClC,CAAC;QACH,CAAC;QAED,MAAM,MAAM,GACV,OAAO,CAAC,IAAI,KAAK,CAAC;YAChB,CAAC,CAAC,OAAO;YACT,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,KAAK,CACd,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,KAAK,wBAAwB,CACtD;gBACH,CAAC,CAAC,YAAY;gBACd,CAAC,CAAC,WAAW,CAAC;QACpB,OAAO,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,CAAC,CAAC;IACxE,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,8DAA8D,CAC/D,CAAC;IACJ,CAAC;AACH,CAAC,CAAC"}

package/dist_ts/nosqldb/classes.connection.d.ts

@@ -0,0 +1,18 @@
+import { SmartdataDb } from './classes.db.js';
+import type { ICapabilities, IOperationOptions, IReadiness } from '../core/interfaces.js';
+export interface INoSqlConnectionOptions {
+    backend: 'nosqldb' | 'mongodb';
+    url: string;
+    database: string;
+    username?: string;
+    password?: string;
+    connectionLimit?: number;
+}
+export declare class NoSqlConnection extends SmartdataDb {
+    readonly options: INoSqlConnectionOptions;
+    readonly backend: 'nosqldb' | 'mongodb';
+    readonly capabilities: ICapabilities;
+    constructor(options: INoSqlConnectionOptions);
+    connect(options?: IOperationOptions): Promise<void>;
+    ready(options?: IOperationOptions): Promise<IReadiness>;
+}

package/dist_ts/nosqldb/classes.connection.js

@@ -0,0 +1,23 @@
+import { SmartdataDb } from './classes.db.js';
+export class NoSqlConnection extends SmartdataDb {
+    options;
+    backend;
+    capabilities;
+    constructor(options) {
+        super({ mongoDbUrl: options.url, mongoDbName: options.database,
+            mongoDbUser: options.username, mongoDbPass: options.password,
+            ...(options.connectionLimit === undefined ? {} : { maxPoolSize: options.connectionLimit }) });
+        this.options = options;
+        this.backend = options.backend;
+        this.capabilities = Object.freeze({ backend: options.backend,
+            transactions: options.backend === 'nosqldb' ? 'available' : 'unknown',
+            changeStreams: options.backend === 'nosqldb' ? 'unsupported' : 'unknown',
+            objectMetrics: 'unsupported', diskResidentScans: 'available' });
+    }
+    async connect(options = {}) { await this.init(options); }
+    async ready(options = {}) {
+        const result = await this.checkReadiness(options);
+        return result.ready ? { ready: true } : { ready: false, reason: result.reason };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5jb25uZWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvbm9zcWxkYi9jbGFzc2VzLmNvbm5lY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBWTlDLE1BQU0sT0FBTyxlQUFnQixTQUFRLFdBQVc7SUFHbEI7SUFGWixPQUFPLENBQXdCO0lBQy9CLFlBQVksQ0FBZ0I7SUFDNUMsWUFBNEIsT0FBZ0M7UUFDMUQsS0FBSyxDQUFDLEVBQUUsVUFBVSxFQUFFLE9BQU8sQ0FBQyxHQUFHLEVBQUUsV0FBVyxFQUFFLE9BQU8sQ0FBQyxRQUFRO1lBQzVELFdBQVcsRUFBRSxPQUFPLENBQUMsUUFBUSxFQUFFLFdBQVcsRUFBRSxPQUFPLENBQUMsUUFBUTtZQUM1RCxHQUFHLENBQUMsT0FBTyxDQUFDLGVBQWUsS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxXQUFXLEVBQUUsT0FBTyxDQUFDLGVBQWUsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBSHRFLFlBQU8sR0FBUCxPQUFPLENBQXlCO1FBSTFELElBQUksQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQztRQUMvQixJQUFJLENBQUMsWUFBWSxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxPQUFPLEVBQUUsT0FBTyxDQUFDLE9BQU87WUFDMUQsWUFBWSxFQUFFLE9BQU8sQ0FBQyxPQUFPLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLFNBQVM7WUFDckUsYUFBYSxFQUFFLE9BQU8sQ0FBQyxPQUFPLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDLFNBQVM7WUFDeEUsYUFBYSxFQUFFLGFBQWEsRUFBRSxpQkFBaUIsRUFBRSxXQUFXLEVBQUUsQ0FBQyxDQUFDO0lBQ3BFLENBQUM7SUFDTSxLQUFLLENBQUMsT0FBTyxDQUFDLFVBQTZCLEVBQUUsSUFBbUIsTUFBTSxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUMzRixLQUFLLENBQUMsS0FBSyxDQUFDLFVBQTZCLEVBQUU7UUFDaEQsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2xELE9BQU8sTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDLE1BQU0sRUFBRSxDQUFDO0lBQ2xGLENBQUM7Q0FDRiJ9

package/dist_ts/nosqldb/classes.convenience.d.ts

@@ -0,0 +1 @@
+export declare const getNewUniqueId: (prefixArg?: string) => Promise<string>;

package/dist_ts/nosqldb/classes.convenience.js

@@ -0,0 +1,5 @@
+import * as plugins from './plugins.js';
+export const getNewUniqueId = async (prefixArg) => {
+    return plugins.smartunique.uni(prefixArg);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5jb252ZW5pZW5jZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL25vc3FsZGIvY2xhc3Nlcy5jb252ZW5pZW5jZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUV4QyxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsS0FBSyxFQUFFLFNBQWtCLEVBQUUsRUFBRTtJQUN6RCxPQUFPLE9BQU8sQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0FBQzVDLENBQUMsQ0FBQyJ9

package/dist_ts/nosqldb/classes.cursor.d.ts

@@ -0,0 +1,15 @@
+import { SmartDataDbDoc } from './classes.doc.js';
+import * as plugins from './plugins.js';
+/**
+ * a wrapper for the native mongodb cursor. Exposes better
+ */
+export declare class SmartdataDbCursor<T = any> {
+    mongodbCursor: plugins.mongodb.FindCursor<T>;
+    private smartdataDbDoc;
+    constructor(cursorArg: plugins.mongodb.FindCursor<T>, dbDocArg: typeof SmartDataDbDoc);
+    next(closeAtEnd?: boolean): Promise<T | null>;
+    forEach(forEachFuncArg: (itemArg: T) => Promise<any>, closeCursorAtEnd?: boolean): Promise<void>;
+    toArray(): Promise<T[]>;
+    close(): Promise<void>;
+    private closeAfterError;
+}

package/dist_ts/nosqldb/classes.cursor.js

@@ -0,0 +1,82 @@
+import { SmartDataDbDoc } from './classes.doc.js';
+import * as plugins from './plugins.js';
+/**
+ * a wrapper for the native mongodb cursor. Exposes better
+ */
+export class SmartdataDbCursor {
+    // STATIC
+    // INSTANCE
+    mongodbCursor;
+    smartdataDbDoc;
+    constructor(cursorArg, dbDocArg) {
+        this.mongodbCursor = cursorArg;
+        this.smartdataDbDoc = dbDocArg;
+    }
+    async next(closeAtEnd = true) {
+        let nextDocument;
+        try {
+            nextDocument = await this.mongodbCursor.next();
+        }
+        catch (readError) {
+            return await this.closeAfterError(readError);
+        }
+        if (nextDocument === null) {
+            if (closeAtEnd) {
+                await this.close();
+            }
+            return null;
+        }
+        try {
+            return this.smartdataDbDoc.createInstanceFromMongoDbNativeDoc(nextDocument);
+        }
+        catch (conversionError) {
+            return await this.closeAfterError(conversionError);
+        }
+    }
+    async forEach(forEachFuncArg, closeCursorAtEnd = true) {
+        try {
+            let nextDocument;
+            do {
+                nextDocument = await this.mongodbCursor.next();
+                if (nextDocument) {
+                    const nextClassInstance = this.smartdataDbDoc.createInstanceFromMongoDbNativeDoc(nextDocument);
+                    await forEachFuncArg(nextClassInstance);
+                }
+            } while (nextDocument);
+        }
+        catch (iterationError) {
+            if (closeCursorAtEnd) {
+                await this.closeAfterError(iterationError);
+            }
+            throw iterationError;
+        }
+        if (closeCursorAtEnd) {
+            await this.close();
+        }
+    }
+    async toArray() {
+        let convertedResult;
+        try {
+            const result = await this.mongodbCursor.toArray();
+            convertedResult = result.map((itemArg) => this.smartdataDbDoc.createInstanceFromMongoDbNativeDoc(itemArg));
+        }
+        catch (conversionError) {
+            return await this.closeAfterError(conversionError);
+        }
+        await this.close();
+        return convertedResult;
+    }
+    async close() {
+        await this.mongodbCursor.close();
+    }
+    async closeAfterError(errorArg) {
+        try {
+            await this.close();
+        }
+        catch {
+            // Preserve the operation error when cursor cleanup also fails.
+        }
+        throw errorArg;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/nosqldb/classes.cursoroperation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Keep one native cleanup promise, including cleanup started by a driver's
+ * abort listener. This module stays internal: callers receive results only.
+ */
+export declare const runCursorOperation: <TCursor extends {
+    close: (...args: any[]) => Promise<void>;
+}, TResult>(cursorArg: TCursor, operationArg: (cursorArg: TCursor) => Promise<TResult>, signalArg?: AbortSignal, closeArgumentsArg?: () => Parameters<TCursor["close"]>) => Promise<TResult>;

package/dist_ts/nosqldb/classes.cursoroperation.js

@@ -0,0 +1,36 @@
+/**
+ * Keep one native cleanup promise, including cleanup started by a driver's
+ * abort listener. This module stays internal: callers receive results only.
+ */
+export const runCursorOperation = async (cursorArg, operationArg, signalArg, closeArgumentsArg) => {
+    const nativeClose = cursorArg.close.bind(cursorArg);
+    let closePromise;
+    cursorArg.close = (...args) => {
+        closePromise ??= nativeClose(...(closeArgumentsArg?.() ?? args));
+        return closePromise;
+    };
+    const onAbort = () => { void cursorArg.close().catch(() => undefined); };
+    signalArg?.addEventListener('abort', onAbort, { once: true });
+    try {
+        let result;
+        try {
+            signalArg?.throwIfAborted();
+            result = await operationArg(cursorArg);
+            signalArg?.throwIfAborted();
+        }
+        catch (errorArg) {
+            try {
+                await cursorArg.close();
+            }
+            catch { /* Preserve the operation error. */ }
+            throw errorArg;
+        }
+        await cursorArg.close();
+        signalArg?.throwIfAborted();
+        return result;
+    }
+    finally {
+        signalArg?.removeEventListener('abort', onAbort);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5jdXJzb3JvcGVyYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9ub3NxbGRiL2NsYXNzZXMuY3Vyc29yb3BlcmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLEtBQUssRUFJckMsU0FBa0IsRUFDbEIsWUFBc0QsRUFDdEQsU0FBdUIsRUFDdkIsaUJBQXNELEVBQ3BDLEVBQUU7SUFDcEIsTUFBTSxXQUFXLEdBQUcsU0FBUyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDcEQsSUFBSSxZQUF1QyxDQUFDO0lBQzVDLFNBQVMsQ0FBQyxLQUFLLEdBQUcsQ0FBQyxHQUFHLElBQWtDLEVBQUUsRUFBRTtRQUMxRCxZQUFZLEtBQUssV0FBVyxDQUFDLEdBQUcsQ0FBQyxpQkFBaUIsRUFBRSxFQUFFLElBQUksSUFBSSxDQUFDLENBQUMsQ0FBQztRQUNqRSxPQUFPLFlBQVksQ0FBQztJQUN0QixDQUFDLENBQUM7SUFDRixNQUFNLE9BQU8sR0FBRyxHQUFHLEVBQUUsR0FBRyxLQUFLLFNBQVMsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxLQUFLLENBQUMsR0FBRyxFQUFFLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDekUsU0FBUyxFQUFFLGdCQUFnQixDQUFDLE9BQU8sRUFBRSxPQUFPLEVBQUUsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUM5RCxJQUFJLENBQUM7UUFDSCxJQUFJLE1BQWUsQ0FBQztRQUNwQixJQUFJLENBQUM7WUFDSCxTQUFTLEVBQUUsY0FBYyxFQUFFLENBQUM7WUFDNUIsTUFBTSxHQUFHLE1BQU0sWUFBWSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1lBQ3ZDLFNBQVMsRUFBRSxjQUFjLEVBQUUsQ0FBQztRQUM5QixDQUFDO1FBQUMsT0FBTyxRQUFRLEVBQUUsQ0FBQztZQUNsQixJQUFJLENBQUM7Z0JBQUMsTUFBTSxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUM7WUFBQyxDQUFDO1lBQUMsTUFBTSxDQUFDLENBQUMsbUNBQW1DLENBQUMsQ0FBQztZQUM5RSxNQUFNLFFBQVEsQ0FBQztRQUNqQixDQUFDO1FBQ0QsTUFBTSxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDeEIsU0FBUyxFQUFFLGNBQWMsRUFBRSxDQUFDO1FBQzVCLE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7WUFBUyxDQUFDO1FBQ1QsU0FBUyxFQUFFLG1CQUFtQixDQUFDLE9BQU8sRUFBRSxPQUFPLENBQUMsQ0FBQztJQUNuRCxDQUFDO0FBQ0gsQ0FBQyxDQUFDIn0=