@schmock/faker 2.3.0 → 2.3.1

package/dist/field-name-matcher.js

@@ -1,148 +0,0 @@
-import { ALL_FIELD_MAPPINGS } from "./field-mappings.js";
-/**
- * Split a field name (camelCase, snake_case, kebab-case) into lowercase tokens.
- * "userFirstName" → ["user", "first", "name"]
- * "created_at"    → ["created", "at"]
- * "HTMLParser"    → ["html", "parser"]
- * "is_active"     → ["is", "active"]
- */
-export function tokenizeFieldName(name) {
-    // Split on _ and -
-    const parts = name.split(/[_-]/);
-    const tokens = [];
-    for (const part of parts) {
-        if (!part)
-            continue;
-        // Split camelCase and consecutive uppercase (e.g., HTMLParser → HTML, Parser)
-        const camelTokens = part
-            .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
-            .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
-            .split("_");
-        for (const t of camelTokens) {
-            if (t)
-                tokens.push(t.toLowerCase());
-        }
-    }
-    return tokens;
-}
-/**
- * Score how well a set of keyword tokens matches field name tokens.
- * Returns 0-1:
- *   1.0 — exact full match (joined tokens equal joined keywords)
- *   0.9 — all keyword tokens found in field tokens with high coverage (>50%)
- *   0.8 — field ends with keyword tokens
- *   0.7 — substring match (keyword appears in joined field name)
- *   0.65 — all keyword tokens found but low coverage (<=50%)
- */
-export function scoreMatch(fieldTokens, keywords) {
-    const fieldJoined = fieldTokens.join("");
-    let bestScore = 0;
-    // Try each keyword variant, keep the highest score
-    for (const keyword of keywords) {
-        const kwTokens = tokenizeFieldName(keyword);
-        const kwJoined = kwTokens.join("");
-        // Exact match: joined tokens are identical
-        if (fieldJoined === kwJoined)
-            return 1.0;
-        // All keyword tokens present in field tokens with high coverage
-        if (kwTokens.length > 0 &&
-            kwTokens.every((kt) => fieldTokens.includes(kt))) {
-            const coverage = kwTokens.length / fieldTokens.length;
-            const score = coverage > 0.5 ? 0.9 : 0.65;
-            bestScore = Math.max(bestScore, score);
-        }
-        // Field ends with keyword tokens
-        if (kwTokens.length > 0 && kwTokens.length <= fieldTokens.length) {
-            const tail = fieldTokens.slice(-kwTokens.length);
-            if (tail.every((t, i) => t === kwTokens[i])) {
-                bestScore = Math.max(bestScore, 0.8);
-            }
-        }
-        // Substring match: keyword joined appears in field joined
-        if (kwJoined.length >= 3 && fieldJoined.includes(kwJoined)) {
-            bestScore = Math.max(bestScore, 0.7);
-        }
-    }
-    return bestScore;
-}
-/**
- * Find the best field mapping for a given field name and schema.
- * Returns the highest-scoring match above its threshold, or undefined.
- */
-export function findBestMapping(fieldName, schema, mappings = ALL_FIELD_MAPPINGS) {
-    const schemaType = typeof schema.type === "string" ? schema.type : undefined;
-    // Priority: format:uuid always maps to string.uuid
-    if (schemaType === "string" && schema.format === "uuid") {
-        return {
-            mapping: {
-                keywords: ["uuid"],
-                fakerMethod: "string.uuid",
-                schemaType: "string",
-                minScore: 0.5,
-            },
-            score: 1.0,
-        };
-    }
-    // Skip if schema already has pattern, enum, faker, or $ref constraint
-    // Also skip string mappings when minLength/maxLength is set — name-based
-    // mappings (e.g. lorem.word for "label") don't honor JSON Schema length
-    // constraints, so they'd produce out-of-range strings ~20% of the time.
-    // Mirrors the numeric constraint skip just below.
-    if (schema.pattern ||
-        schema.enum ||
-        ("faker" in schema && schema.faker) ||
-        schema.$ref ||
-        (schemaType === "string" &&
-            (schema.minLength !== undefined || schema.maxLength !== undefined))) {
-        return undefined;
-    }
-    // Skip numeric faker mapping when schema already constrains the range
-    const hasNumericConstraints = schema.minimum !== undefined ||
-        schema.maximum !== undefined ||
-        schema.exclusiveMinimum !== undefined ||
-        schema.exclusiveMaximum !== undefined;
-    const tokens = tokenizeFieldName(fieldName);
-    let best;
-    for (const mapping of mappings) {
-        // Skip numeric faker mappings when schema has explicit constraints
-        if (hasNumericConstraints &&
-            (mapping.schemaType === "number" || mapping.schemaType === "integer")) {
-            continue;
-        }
-        // Skip faker mappings for object/array schemas — they generate primitive values
-        if (schemaType === "object" || schemaType === "array") {
-            continue;
-        }
-        // Check schema type constraint
-        if (mapping.schemaType && schemaType && mapping.schemaType !== schemaType) {
-            const isNumeric = (mapping.schemaType === "number" && schemaType === "integer") ||
-                (mapping.schemaType === "integer" && schemaType === "number");
-            if (!isNumeric)
-                continue;
-        }
-        const score = scoreMatch(tokens, mapping.keywords);
-        if (score >= mapping.minScore && (!best || score > best.score)) {
-            best = { mapping, score };
-        }
-    }
-    // ID suffix detection: fields ending in Id/_id with string type → UUID
-    // Only if no better match was found or the existing match is weak
-    if (schemaType === "string") {
-        const lastToken = tokens[tokens.length - 1];
-        if (lastToken === "id" && tokens.length > 1) {
-            const idScore = 0.8;
-            if (!best || best.score < idScore) {
-                best = {
-                    mapping: {
-                        keywords: ["id"],
-                        fakerMethod: "string.uuid",
-                        schemaType: "string",
-                        minScore: 0.5,
-                    },
-                    score: idScore,
-                };
-            }
-        }
-    }
-    return best;
-}

package/dist/jsf-config.js

@@ -1,117 +0,0 @@
-import { base, en, Faker } from "@faker-js/faker";
-import { generate, } from "json-schema-faker";
-const MAX_GENERATION_SEED = 2_147_483_647;
-/**
- * Create isolated faker instance to avoid race conditions.
- * Each generation gets its own faker instance to ensure thread-safety.
- */
-export function createFakerInstance(seed) {
-    const faker = new Faker({ locale: [en, base] });
-    if (seed !== undefined) {
-        faker.seed(seed);
-    }
-    return faker;
-}
-export function resolveGenerationSeed(seed) {
-    return seed ?? Math.floor(Math.random() * MAX_GENERATION_SEED);
-}
-export function createSeededRandom(seed) {
-    let state = seed;
-    return () => {
-        state += 0x6d2b79f5;
-        let value = state;
-        value = Math.imul(value ^ (value >>> 15), value | 1);
-        value ^= value + Math.imul(value ^ (value >>> 7), value | 61);
-        return ((value ^ (value >>> 14)) >>> 0) / 4_294_967_296;
-    };
-}
-function normalizeDefinitionForJsf(definition) {
-    return typeof definition === "boolean"
-        ? definition
-        : normalizeSchemaForJsf(definition);
-}
-function normalizeDefinitionMap(definitions) {
-    return Object.fromEntries(Object.entries(definitions).map(([key, definition]) => [
-        key,
-        normalizeDefinitionForJsf(definition),
-    ]));
-}
-/**
- * json-schema-faker consumes tuple schemas through the 2020-12 `prefixItems`
- * keyword. Convert Draft 7 tuple `items` recursively at the library boundary.
- */
-export function normalizeSchemaForJsf(schema) {
-    const normalized = {};
-    for (const [key, value] of Object.entries(schema)) {
-        normalized[key] = value;
-    }
-    if (schema.properties) {
-        normalized.properties = normalizeDefinitionMap(schema.properties);
-    }
-    if (schema.definitions) {
-        normalized.definitions = normalizeDefinitionMap(schema.definitions);
-    }
-    if (schema.$defs) {
-        normalized.$defs = normalizeDefinitionMap(schema.$defs);
-    }
-    if (schema.patternProperties) {
-        normalized.patternProperties = normalizeDefinitionMap(schema.patternProperties);
-    }
-    if (Array.isArray(schema.items)) {
-        normalized.prefixItems = schema.items.map(normalizeDefinitionForJsf);
-        normalized.items =
-            schema.additionalItems === undefined
-                ? true
-                : normalizeDefinitionForJsf(schema.additionalItems);
-        delete normalized.additionalItems;
-    }
-    else if (schema.items !== undefined) {
-        normalized.items = normalizeDefinitionForJsf(schema.items);
-    }
-    for (const keyword of ["allOf", "anyOf", "oneOf"]) {
-        const definitions = schema[keyword];
-        if (definitions) {
-            normalized[keyword] = definitions.map(normalizeDefinitionForJsf);
-        }
-    }
-    if (schema.additionalProperties !== undefined) {
-        normalized.additionalProperties = normalizeDefinitionForJsf(schema.additionalProperties);
-    }
-    for (const keyword of [
-        "contains",
-        "not",
-        "if",
-        "then",
-        "else",
-        "propertyNames",
-    ]) {
-        const definition = schema[keyword];
-        if (definition !== undefined) {
-            normalized[keyword] = normalizeDefinitionForJsf(definition);
-        }
-    }
-    if (schema.dependencies) {
-        normalized.dependencies = Object.fromEntries(Object.entries(schema.dependencies).map(([key, dependency]) => [
-            key,
-            Array.isArray(dependency)
-                ? [...dependency]
-                : normalizeDefinitionForJsf(dependency),
-        ]));
-    }
-    return normalized;
-}
-/**
- * Generate data from a JSON schema using json-schema-faker 0.6.0 async API.
- * Stateless — each call is self-contained with its own faker instance and options.
- */
-export async function generateWithJsf(schema, seed) {
-    const options = {
-        seed,
-        optionalsProbability: 1.0,
-        alwaysFakeOptionals: true,
-        useDefaultValue: true,
-        failOnInvalidTypes: false,
-        extensions: { faker: createFakerInstance(seed) },
-    };
-    return generate(normalizeSchemaForJsf(schema), options);
-}

package/dist/overrides.js

@@ -1,137 +0,0 @@
-import { DEFAULT_ARRAY_COUNT } from "./constants.js";
-const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
- * Determine number of items to generate for array schema
- * Prefers explicit count, then schema minItems/maxItems, with sane defaults
- * @param schema - Array schema with optional minItems/maxItems
- * @param explicitCount - Explicit count override from plugin options
- * @returns Number of array items to generate
- */
-export function determineArrayCount(schema, explicitCount, random = Math.random) {
-    if (explicitCount !== undefined) {
-        // Handle negative or invalid counts
-        if (explicitCount < 0) {
-            return 0;
-        }
-        return explicitCount;
-    }
-    if (schema.minItems !== undefined && schema.maxItems !== undefined) {
-        const min = schema.minItems;
-        const max = Math.max(min, schema.maxItems);
-        return Math.floor(random() * (max - min + 1)) + min;
-    }
-    if (schema.minItems !== undefined) {
-        return Math.max(schema.minItems, DEFAULT_ARRAY_COUNT);
-    }
-    if (schema.maxItems !== undefined) {
-        return Math.min(schema.maxItems, DEFAULT_ARRAY_COUNT);
-    }
-    if (Array.isArray(schema.items)) {
-        return schema.items.length;
-    }
-    return DEFAULT_ARRAY_COUNT;
-}
-/**
- * Apply overrides to generated data with support for templates
- * Supports nested paths (dot notation), templates with {{params.id}}, and state access
- * @param data - Generated data to apply overrides to
- * @param overrides - Override values (can use templates)
- * @param params - Route parameters for template expansion
- * @param state - Plugin state for template expansion
- * @param query - Query parameters for template expansion
- * @returns Data with overrides applied
- */
-export function applyOverrides(data, overrides, params, state, query) {
-    if (!overrides)
-        return data;
-    if (!isRecord(data))
-        return data;
-    const result = structuredClone(data);
-    for (const [key, value] of Object.entries(overrides)) {
-        if (DANGEROUS_KEYS.has(key))
-            continue;
-        // Handle nested paths like "data.id" or "pagination.page"
-        if (key.includes(".")) {
-            setNestedProperty(result, key, value, { params, state, query });
-        }
-        else {
-            // Handle flat keys and nested objects
-            if (isRecord(value)) {
-                // Recursively apply nested overrides
-                if (isRecord(result[key])) {
-                    result[key] = applyOverrides(result[key], value, params, state, query);
-                }
-                else {
-                    result[key] = applyOverrides({}, value, params, state, query);
-                }
-            }
-            else if (typeof value === "string" && value.includes("{{")) {
-                // Template processing
-                result[key] = processTemplate(value, { params, state, query });
-            }
-            else {
-                result[key] = value;
-            }
-        }
-    }
-    return result;
-}
-function setNestedProperty(obj, path, value, context) {
-    const parts = path.split(".");
-    let current = obj;
-    // Navigate to the parent of the target property
-    for (let i = 0; i < parts.length - 1; i++) {
-        const part = parts[i];
-        if (DANGEROUS_KEYS.has(part))
-            return;
-        const next = current[part];
-        if (isRecord(next)) {
-            current = next;
-        }
-        else {
-            const nested = {};
-            current[part] = nested;
-            current = nested;
-        }
-    }
-    // Set the final property
-    const finalKey = parts[parts.length - 1];
-    if (DANGEROUS_KEYS.has(finalKey))
-        return;
-    if (typeof value === "string" && value.includes("{{")) {
-        current[finalKey] = processTemplate(value, context);
-    }
-    else {
-        current[finalKey] = value;
-    }
-}
-function resolveTemplatePath(context, expression) {
-    const parts = expression.trim().split(".");
-    let result = context;
-    for (const part of parts) {
-        if (isRecord(result)) {
-            result = result[part];
-        }
-        else {
-            return undefined;
-        }
-    }
-    return result;
-}
-function processTemplate(template, context) {
-    // Check if the template is just a single template expression
-    const singleTemplateMatch = template.match(/^\{\{\s*([^}]+)\s*\}\}$/);
-    if (singleTemplateMatch) {
-        // For single templates, return the actual value without string conversion
-        const result = resolveTemplatePath(context, singleTemplateMatch[1]);
-        return result !== undefined ? result : template;
-    }
-    // For templates mixed with other text, do string replacement
-    return template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (match, expression) => {
-        const result = resolveTemplatePath(context, expression);
-        return result !== undefined ? String(result) : match;
-    });
-}

package/dist/schema-enhancement.js

@@ -1,104 +0,0 @@
-import { findBestMapping } from "./field-name-matcher.js";
-import { isJSONSchema7, validateFakerMethod } from "./validation.js";
-function needsStringFallback(schema) {
-    return (schema.type === "string" &&
-        schema.faker === undefined &&
-        schema.format === undefined &&
-        schema.pattern === undefined &&
-        schema.enum === undefined &&
-        schema.const === undefined &&
-        schema.$ref === undefined &&
-        schema.minLength === undefined &&
-        schema.maxLength === undefined);
-}
-export function enhanceSchemaWithSmartMapping(schema) {
-    if (!schema || typeof schema !== "object") {
-        return schema;
-    }
-    const enhanced = { ...schema };
-    // Handle object properties
-    if (enhanced.properties) {
-        enhanced.properties = { ...enhanced.properties };
-        for (const [fieldName, fieldSchema] of Object.entries(enhanced.properties)) {
-            if (isJSONSchema7(fieldSchema)) {
-                enhanced.properties[fieldName] = enhanceFieldSchema(fieldName, fieldSchema);
-            }
-        }
-    }
-    // Recurse into composition keywords
-    for (const keyword of ["allOf", "anyOf", "oneOf"]) {
-        const branches = enhanced[keyword];
-        if (Array.isArray(branches)) {
-            enhanced[keyword] = branches.map((branch) => isJSONSchema7(branch) ? enhanceSchemaWithSmartMapping(branch) : branch);
-        }
-    }
-    // Recurse into array items
-    if (enhanced.items) {
-        if (Array.isArray(enhanced.items)) {
-            enhanced.items = enhanced.items.map((item) => isJSONSchema7(item) ? enhanceSchemaWithSmartMapping(item) : item);
-        }
-        else if (isJSONSchema7(enhanced.items)) {
-            enhanced.items = enhanceSchemaWithSmartMapping(enhanced.items);
-        }
-    }
-    // Recurse into additionalProperties
-    if (isJSONSchema7(enhanced.additionalProperties)) {
-        enhanced.additionalProperties = enhanceSchemaWithSmartMapping(enhanced.additionalProperties);
-    }
-    if (needsStringFallback(enhanced)) {
-        enhanced.faker = "lorem.word";
-    }
-    return enhanced;
-}
-function enhanceFieldSchema(fieldName, fieldSchema) {
-    const enhanced = { ...fieldSchema };
-    // If already has faker extension, validate it and don't override.
-    // User-supplied faker values are always strings; the object form is only
-    // produced internally by this function when fakerArgs are present.
-    if (enhanced.faker) {
-        if (typeof enhanced.faker === "string") {
-            validateFakerMethod(enhanced.faker);
-        }
-        return enhanced;
-    }
-    // Recursively enhance nested schemas first
-    const hasComposition = enhanced.allOf || enhanced.anyOf || enhanced.oneOf;
-    if (enhanced.properties || hasComposition || enhanced.items) {
-        const recursed = enhanceSchemaWithSmartMapping(enhanced);
-        Object.assign(enhanced, recursed);
-    }
-    // Don't apply field-level faker mapping to composition schemas — the branches define their own types
-    if (hasComposition) {
-        return enhanced;
-    }
-    // Don't apply smart mapping when const or enum is defined — these have fixed values
-    if (enhanced.const !== undefined || enhanced.enum) {
-        return enhanced;
-    }
-    // Apply smart field name mapping via the scoring matcher
-    const match = findBestMapping(fieldName, enhanced);
-    if (match) {
-        const { fakerMethod, format, trueProbability, fakerArgs } = match.mapping;
-        // Use the JSF object form when fakerArgs are present so the options object
-        // is forwarded to the faker method (e.g. number.int({ min, max })).
-        // JSF calls Q(...J) where J is the value, so we must wrap fakerArgs in an
-        // array: { "number.int": [{ min, max }] } → faker.number.int({ min, max }).
-        // Fall back to the plain string form when there are no args.
-        if (fakerArgs) {
-            enhanced.faker = { [fakerMethod]: [fakerArgs] };
-        }
-        else {
-            enhanced.faker = fakerMethod;
-        }
-        if (format) {
-            enhanced.format = format;
-        }
-        if (trueProbability !== undefined) {
-            enhanced.schmockTrueProbability = trueProbability;
-        }
-    }
-    else if (needsStringFallback(enhanced)) {
-        enhanced.faker = "lorem.word";
-    }
-    return enhanced;
-}

package/dist/test-utils.d.ts

@@ -1,57 +0,0 @@
-import type { JSONSchema7 } from "json-schema";
-interface FakerSchema extends JSONSchema7 {
-    faker?: string;
-}
-export declare const schemas: {
-    simple: {
-        string: () => JSONSchema7;
-        number: () => JSONSchema7;
-        object: (properties?: Record<string, JSONSchema7>) => JSONSchema7;
-        array: (items: JSONSchema7, constraints?: {
-            minItems?: number;
-            maxItems?: number;
-        }) => JSONSchema7;
-    };
-    withFaker: (type: JSONSchema7["type"], fakerMethod: string) => FakerSchema;
-    nested: {
-        deep: (depth: number, leafSchema?: JSONSchema7) => JSONSchema7;
-        wide: (width: number, propertySchema?: JSONSchema7) => JSONSchema7;
-    };
-    complex: {
-        user: () => JSONSchema7;
-        apiResponse: () => JSONSchema7;
-    };
-};
-export declare const validators: {
-    isFieldMapped: (fieldName: string, fieldType?: JSONSchema7["type"]) => Promise<boolean>;
-    uniquenessRatio: (samples: unknown[]) => number;
-    allMatch: <T>(samples: T[], validator: (sample: T) => boolean) => boolean;
-    appearsToBeFromCategory: (samples: string[], category: "email" | "name" | "phone" | "address" | "uuid" | "date") => boolean;
-};
-export declare const performance: {
-    measure: <T>(fn: () => T | Promise<T>) => Promise<{
-        result: T;
-        duration: number;
-    }>;
-    measureMemory: (fn: () => void) => number;
-    benchmark: (_name: string, fn: () => unknown | Promise<unknown>, iterations?: number) => Promise<{
-        mean: number;
-        min: number;
-        max: number;
-    }>;
-};
-export declare const generate: {
-    samples: (schema: JSONSchema7, count?: number, options?: Omit<Schmock.SchemaGenerationContext, "schema">) => Promise<unknown[]>;
-    withSeed: (schema: JSONSchema7, seed?: number) => Promise<unknown>;
-};
-export declare const stats: {
-    distribution: (samples: unknown[]) => Map<string, number>;
-    entropy: (samples: unknown[]) => number;
-};
-export declare const schemaTests: {
-    expectValid: (schema: JSONSchema7) => Promise<void>;
-    expectInvalid: (schema: JSONSchema7, errorMessage?: string | RegExp) => Promise<void>;
-    expectSchemaError: (schema: JSONSchema7, path: string, issue?: string) => Promise<void>;
-};
-export {};
-//# sourceMappingURL=test-utils.d.ts.map

package/dist/test-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI/C,UAAU,WAAY,SAAQ,WAAW;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAOD,eAAO,MAAM,OAAO;;sBAEJ,WAAW;sBAIX,WAAW;8BAIF,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,KAAQ,WAAW;uBAM1D,WAAW,gBACJ;YAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;SAAE,KACrD,WAAW;;sBAOE,WAAW,CAAC,MAAM,CAAC,eAAe,MAAM,KAAG,WAAW;;sBAO7D,MAAM,eACD,WAAW,KACtB,WAAW;sBAWL,MAAM,mBACG,WAAW,KAC1B,WAAW;;;oBASJ,WAAW;2BAYJ,WAAW;;CAkB/B,CAAC;AAGF,eAAO,MAAM,UAAU;+BAGR,MAAM,cACN,WAAW,CAAC,MAAM,CAAC,KAC7B,OAAO,CAAC,OAAO,CAAC;+BAmDQ,OAAO,EAAE,KAAG,MAAM;eAMlC,CAAC,WAAW,CAAC,EAAE,aAAa,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,KAAG,OAAO;uCAM5D,MAAM,EAAE,YACP,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,KACjE,OAAO;CAgDX,CAAC;AAGF,eAAO,MAAM,WAAW;cACN,CAAC,MACX,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,KACvB,OAAO,CAAC;QAAE,MAAM,EAAE,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;wBAOvB,MAAM,IAAI,KAAG,MAAM;uBAW9B,MAAM,MACT,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,0BAEnC,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CAgBvD,CAAC;AAGF,eAAO,MAAM,QAAQ;sBAET,WAAW,4BAET,IAAI,CAAC,OAAO,CAAC,uBAAuB,EAAE,QAAQ,CAAC,KACxD,OAAO,CAAC,OAAO,EAAE,CAAC;uBAQI,WAAW,SAAS,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;CAGvE,CAAC;AAGF,eAAO,MAAM,KAAK;4BACQ,OAAO,EAAE,KAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;uBASpC,OAAO,EAAE,KAAG,MAAM;CActC,CAAC;AAGF,eAAO,MAAM,WAAW;0BACM,WAAW,KAAG,OAAO,CAAC,IAAI,CAAC;4BAK7C,WAAW,iBACJ,MAAM,GAAG,MAAM,KAC7B,OAAO,CAAC,IAAI,CAAC;gCAWN,WAAW,QACb,MAAM,UACJ,MAAM,KACb,OAAO,CAAC,IAAI,CAAC;CAuBjB,CAAC"}