@skmtc/core 0.0.794 → 0.0.795

package/esm/typescript/FunctionParameter.js

@@ -3,14 +3,183 @@ import { camelCase } from 'lodash-es';
 import { match, P } from 'ts-pattern';
 import { List } from './List.js';
 import { isEmpty } from '../helpers/isEmpty.js';
+/**
+ * Generates TypeScript function parameters with advanced handling for different parameter patterns.
+ *
+ * `FunctionParameter` is a sophisticated utility for generating TypeScript function parameter
+ * syntax that handles multiple parameter patterns including named parameters, destructured
+ * object parameters, and void parameters. It provides intelligent type handling and can
+ * generate both the parameter declaration and the parameter usage patterns.
+ *
+ * This class is essential for generating type-safe function signatures in API clients,
+ * utility functions, and other generated code where parameters need to be handled
+ * consistently and safely.
+ *
+ * ## Supported Parameter Patterns
+ *
+ * - **Named Parameters**: Traditional `paramName: Type` syntax
+ * - **Destructured Parameters**: `{ prop1, prop2 }: ObjectType` syntax
+ * - **Void Parameters**: No parameters when dealing with void types
+ * - **Optional Parameters**: Automatic handling of optional parameter markers
+ * - **Empty Filtering**: Option to skip empty properties in destructured objects
+ *
+ * @example Named parameter generation
+ * ```typescript
+ * import { FunctionParameter, Definition, Identifier } from '@skmtc/core';
+ *
+ * const userIdParam = new FunctionParameter({
+ *   name: 'userId',
+ *   typeDefinition: new Definition({
+ *     context: generateContext,
+ *     identifier: Identifier.createType('string'),
+ *     value: { type: 'string' }
+ *   }),
+ *   required: true
+ * });
+ *
+ * console.log(userIdParam.toString()); // 'userId: string'
+ * console.log(userIdParam.toInbound()); // 'userId'
+ * ```
+ *
+ * @example Destructured parameter generation
+ * ```typescript
+ * const destructuredParam = new FunctionParameter({
+ *   typeDefinition: new Definition({
+ *     context: generateContext,
+ *     identifier: Identifier.createType('UserParams'),
+ *     value: {
+ *       type: 'object',
+ *       objectProperties: {
+ *         properties: {
+ *           name: { type: 'string' },
+ *           email: { type: 'string' },
+ *           age: { type: 'number' }
+ *         }
+ *       }
+ *     }
+ *   }),
+ *   destructure: true,
+ *   required: true
+ * });
+ *
+ * console.log(destructuredParam.toString());
+ * // '{ name, email, age }: UserParams'
+ *
+ * console.log(destructuredParam.toInbound());
+ * // '{ name, email, age }'
+ * ```
+ *
+ * @example Optional parameter handling
+ * ```typescript
+ * const optionalParam = new FunctionParameter({
+ *   name: 'options',
+ *   typeDefinition: optionsTypeDefinition,
+ *   required: false
+ * });
+ *
+ * console.log(optionalParam.toString()); // 'options?: OptionsType'
+ * ```
+ *
+ * @example Void parameter handling
+ * ```typescript
+ * const voidParam = new FunctionParameter({
+ *   typeDefinition: new Definition({
+ *     context: generateContext,
+ *     identifier: Identifier.createType('void'),
+ *     value: { type: 'void' }
+ *   })
+ * });
+ *
+ * console.log(voidParam.toString()); // ''
+ * console.log(voidParam.toInbound()); // ''
+ * ```
+ *
+ * @example Property checking
+ * ```typescript
+ * const objectParam = new FunctionParameter({
+ *   typeDefinition: userTypeDefinition,
+ *   destructure: true,
+ *   required: true
+ * });
+ *
+ * if (objectParam.hasProperty('email')) {
+ *   // Handle email property access
+ *   console.log('Parameter includes email property');
+ * }
+ *
+ * const propertyList = objectParam.toPropertyList();
+ * console.log(propertyList.toString()); // 'name, email, age'
+ * ```
+ *
+ * @example API method generation with parameters
+ * ```typescript
+ * class ApiMethodGenerator {
+ *   generateMethod(
+ *     methodName: string,
+ *     pathParams?: FunctionParameter,
+ *     bodyParam?: FunctionParameter
+ *   ) {
+ *     const parameters = [pathParams, bodyParam]
+ *       .filter(p => p && p.toString())
+ *       .map(p => p!.toString())
+ *       .join(', ');
+ *
+ *     const pathInbound = pathParams?.toInbound() || '';
+ *     const bodyInbound = bodyParam?.toInbound() || '';
+ *
+ *     return `
+ * async ${methodName}(${parameters}) {
+ *   const path = this.buildPath(${pathInbound});
+ *   return this.request('POST', path, ${bodyInbound});
+ * }`;
+ *   }
+ * }
+ * ```
+ *
+ * @example Empty property filtering
+ * ```typescript
+ * const filteredParam = new FunctionParameter({
+ *   typeDefinition: sparseObjectDefinition,
+ *   destructure: true,
+ *   required: true,
+ *   skipEmpty: true // Skip properties with empty types
+ * });
+ *
+ * // Only non-empty properties will be included in destructuring
+ * console.log(filteredParam.toString());
+ * // '{ validProp1, validProp2 }: FilteredType' (empty props omitted)
+ * ```
+ */
 export class FunctionParameter {
+    /**
+     * Creates a new FunctionParameter instance with the specified configuration.
+     *
+     * The constructor analyzes the provided type definition and configuration options
+     * to determine the appropriate parameter pattern (void, regular, or destructured).
+     * It handles the complex logic of parameter type determination and validation.
+     *
+     * @param args - Configuration options for the function parameter
+     *
+     * @throws {Error} When the parameter configuration is invalid
+     *
+     * @example
+     * ```typescript
+     * const param = new FunctionParameter({
+     *   name: 'userData',
+     *   typeDefinition: userTypeDefinition,
+     *   required: true
+     * });
+     * ```
+     */
     constructor(args) {
+        /** The internal parameter configuration determining how the parameter is generated */
         Object.defineProperty(this, "properties", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /** Whether to skip empty properties in destructured parameters */
         Object.defineProperty(this, "skipEmpty", {
             enumerable: true,
             configurable: true,
@@ -39,6 +208,34 @@ export class FunctionParameter {
             this.properties = { type: 'void' };
         }
     }
+    /**
+     * Checks if the parameter has a specific property (for object-based parameters).
+     *
+     * This method determines whether a given property name exists within the parameter's
+     * type structure. It's useful for conditional code generation based on available
+     * properties and only returns true for object-based parameters (regular object
+     * parameters or destructured parameters).
+     *
+     * @param name - The property name to check for
+     * @returns True if the property exists in the parameter's type structure
+     *
+     * @example
+     * ```typescript
+     * const userParam = new FunctionParameter({
+     *   typeDefinition: userTypeDefinition, // has properties: name, email, age
+     *   destructure: true,
+     *   required: true
+     * });
+     *
+     * if (userParam.hasProperty('email')) {
+     *   console.log('Parameter includes email property');
+     * }
+     *
+     * if (userParam.hasProperty('nonexistent')) {
+     *   // This won't execute
+     * }
+     * ```
+     */
     hasProperty(name) {
         return match(this.properties)
             .with({ type: 'void' }, () => false)
@@ -51,6 +248,37 @@ export class FunctionParameter {
         })
             .exhaustive();
     }
+    /**
+     * Generates a List of property names from the parameter.
+     *
+     * This method extracts property names from object-based parameters and returns
+     * them as a List instance. For regular parameters, it returns the parameter name,
+     * for destructured parameters it returns all object properties, and for void
+     * parameters it returns an empty list.
+     *
+     * @returns List containing the relevant property or parameter names
+     *
+     * @example
+     * ```typescript
+     * const destructuredParam = new FunctionParameter({
+     *   typeDefinition: userTypeDefinition, // has properties: name, email, age
+     *   destructure: true,
+     *   required: true
+     * });
+     *
+     * const propertyList = destructuredParam.toPropertyList();
+     * console.log(propertyList.toString()); // 'name, email, age'
+     *
+     * const regularParam = new FunctionParameter({
+     *   name: 'userData',
+     *   typeDefinition: userTypeDefinition,
+     *   required: true
+     * });
+     *
+     * const regularList = regularParam.toPropertyList();
+     * console.log(regularList.toString()); // 'userData'
+     * ```
+     */
     toPropertyList() {
         return match(this.properties)
             .with({ type: 'void' }, () => List.toEmpty())
@@ -60,6 +288,35 @@ export class FunctionParameter {
         })
             .exhaustive();
     }
+    /**
+     * Generates the inbound parameter syntax for function calls.
+     *
+     * This method produces the syntax used when calling a function with this parameter.
+     * For regular parameters, it returns the parameter name. For destructured parameters,
+     * it returns the destructured object syntax. For void parameters, it returns an
+     * empty string.
+     *
+     * @returns The inbound parameter syntax string
+     *
+     * @example
+     * ```typescript
+     * const regularParam = new FunctionParameter({
+     *   name: 'userId',
+     *   typeDefinition: stringTypeDefinition,
+     *   required: true
+     * });
+     *
+     * console.log(regularParam.toInbound()); // 'userId'
+     *
+     * const destructuredParam = new FunctionParameter({
+     *   typeDefinition: userTypeDefinition,
+     *   destructure: true,
+     *   required: true
+     * });
+     *
+     * console.log(destructuredParam.toInbound()); // '{ name, email, age }'
+     * ```
+     */
     toInbound() {
         return match(this.properties)
             .with({ type: 'void' }, () => '')
@@ -69,6 +326,42 @@ export class FunctionParameter {
         })
             .exhaustive();
     }
+    /**
+     * Generates the complete function parameter declaration syntax.
+     *
+     * This method produces the full parameter declaration that appears in a function
+     * signature, including the parameter name, type annotation, and optional markers.
+     * It handles all parameter patterns supported by the class.
+     *
+     * @returns The complete parameter declaration string
+     *
+     * @example
+     * ```typescript
+     * const requiredParam = new FunctionParameter({
+     *   name: 'userId',
+     *   typeDefinition: stringTypeDefinition,
+     *   required: true
+     * });
+     *
+     * console.log(requiredParam.toString()); // 'userId: string'
+     *
+     * const optionalParam = new FunctionParameter({
+     *   name: 'options',
+     *   typeDefinition: optionsTypeDefinition,
+     *   required: false
+     * });
+     *
+     * console.log(optionalParam.toString()); // 'options?: OptionsType'
+     *
+     * const destructuredParam = new FunctionParameter({
+     *   typeDefinition: userTypeDefinition,
+     *   destructure: true,
+     *   required: true
+     * });
+     *
+     * console.log(destructuredParam.toString()); // '{ name, email, age }: UserType'
+     * ```
+     */
     toString() {
         return match(this.properties)
             .with({ type: 'void' }, () => '')
@@ -86,6 +379,41 @@ export class FunctionParameter {
             .exhaustive();
     }
 }
+/**
+ * Generates destructured object parameter syntax from a type definition.
+ *
+ * This helper function creates the destructured parameter syntax for object types,
+ * handling property name validation and optional camelCase conversion for invalid
+ * JavaScript identifiers. It integrates with the List system to produce properly
+ * formatted destructured parameter lists.
+ *
+ * @param typeDefinition - The object type definition to destructure
+ * @param options - Options for controlling the destructuring behavior
+ * @param options.skipEmpty - Whether to skip empty properties
+ * @returns List instance representing the destructured parameter structure
+ *
+ * @example
+ * ```typescript
+ * const objectDef = new Definition({
+ *   context: generateContext,
+ *   identifier: Identifier.createType('ApiParams'),
+ *   value: {
+ *     type: 'object',
+ *     objectProperties: {
+ *       properties: {
+ *         'user-id': { type: 'string' },
+ *         'valid_name': { type: 'string' },
+ *         'api-key': { type: 'string' }
+ *       }
+ *     }
+ *   }
+ * });
+ *
+ * const result = toDestructured(objectDef);
+ * console.log(result.toString());
+ * // "{ 'user-id': userId, valid_name, 'api-key': apiKey }"
+ * ```
+ */
 const toDestructured = (typeDefinition, { skipEmpty } = {}) => {
     return List.fromKeys(typeDefinition.value.objectProperties?.properties).toObject(key => {
         return isIdentifierName(key) ? key : List.toKeyValue(key, camelCase(key));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skmtc/core",
-  "version": "0.0.794",
+  "version": "0.0.795",
   "repository": {
     "type": "git",
     "url": "https://github.com/skmtc/skmtc.git"

package/script/context/StackTrail.d.ts

@@ -1,18 +1,311 @@
 import "../_dnt.polyfills.js";
+/**
+ * Represents a stack-based trail for tracking document traversal in OpenAPI processing.
+ *
+ * The `StackTrail` class maintains a stack of string frames that represent the current
+ * path through an OpenAPI document structure. It's used throughout the SKMTC pipeline
+ * for tracking context during parsing, generating, and debugging schema processing.
+ *
+ * This class is essential for error reporting, debugging, and maintaining context
+ * when processing nested OpenAPI structures like schemas, operations, and components.
+ *
+ * ## Key Features
+ *
+ * - **Path Tracking**: Maintains a trail of traversed document elements
+ * - **Context Preservation**: Preserves parsing context for error reporting
+ * - **Stack Operations**: Supports push, pop, clone, and manipulation operations
+ * - **Reference Resolution**: Can generate OpenAPI reference strings from trails
+ * - **Serialization**: Supports string serialization and parsing for persistence
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { StackTrail } from '@skmtc/core';
+ *
+ * // Start with empty trail
+ * const trail = new StackTrail();
+ *
+ * // Build a path through document structure
+ * trail.append('components')
+ *      .append('schemas')
+ *      .append('User')
+ *      .append('properties')
+ *      .append('name');
+ *
+ * console.log(trail.toString()); // 'components:schemas:User:properties:name'
+ * ```
+ *
+ * @example Schema reference generation
+ * ```typescript
+ * const schemaTrail = new StackTrail(['components', 'schemas', 'User']);
+ * const ref = schemaTrail.toStackRef();
+ * console.log(ref); // '#/components/schemas/User'
+ * ```
+ *
+ * @example Error context tracking
+ * ```typescript
+ * class SchemaProcessor {
+ *   processSchema(schema: OasSchema, trail: StackTrail) {
+ *     try {
+ *       // Process schema logic
+ *       return this.transformSchema(schema);
+ *     } catch (error) {
+ *       throw new Error(`Error at ${trail.toString()}: ${error.message}`);
+ *       // Error at components:schemas:User:properties:email: Invalid format
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example Cloning and manipulation
+ * ```typescript
+ * const baseTrail = new StackTrail(['components', 'schemas']);
+ *
+ * // Clone for processing different schemas
+ * const userTrail = baseTrail.clone().append('User');
+ * const productTrail = baseTrail.clone().append('Product');
+ *
+ * console.log(userTrail.toString());    // 'components:schemas:User'
+ * console.log(productTrail.toString()); // 'components:schemas:Product'
+ * console.log(baseTrail.toString());    // 'components:schemas' (unchanged)
+ * ```
+ */
 export declare class StackTrail {
     #private;
+    /**
+     * Creates a new StackTrail instance.
+     *
+     * @param stack - Initial stack frames (defaults to empty array)
+     *
+     * @example
+     * ```typescript
+     * // Empty trail
+     * const trail1 = new StackTrail();
+     *
+     * // Pre-populated trail
+     * const trail2 = new StackTrail(['components', 'schemas', 'User']);
+     * ```
+     */
     constructor(stack?: string[]);
+    /**
+     * Creates a shallow copy of the stack trail.
+     *
+     * @returns A new StackTrail instance with copied frames
+     *
+     * @example
+     * ```typescript
+     * const original = new StackTrail(['components', 'schemas']);
+     * const copy = original.clone();
+     *
+     * copy.append('User');
+     * console.log(original.toString()); // 'components:schemas'
+     * console.log(copy.toString());     // 'components:schemas:User'
+     * ```
+     */
     clone(): StackTrail;
+    /**
+     * Creates a new trail from a slice of the current trail.
+     *
+     * @param start - Starting index (inclusive)
+     * @param end - Ending index (exclusive, optional)
+     * @returns A new StackTrail with sliced frames
+     *
+     * @example
+     * ```typescript
+     * const trail = new StackTrail(['a', 'b', 'c', 'd', 'e']);
+     *
+     * const slice1 = trail.slice(1, 3);
+     * console.log(slice1.toString()); // 'b:c'
+     *
+     * const slice2 = trail.slice(2);
+     * console.log(slice2.toString()); // 'c:d:e'
+     * ```
+     */
     slice(start: number, end?: number): StackTrail;
+    /**
+     * Checks if all specified frames exist in the trail.
+     *
+     * @param frames - Array of frames to check for
+     * @returns True if all frames are present in the trail
+     *
+     * @example
+     * ```typescript
+     * const trail = new StackTrail(['components', 'schemas', 'User', 'properties']);
+     *
+     * console.log(trail.includes(['schemas', 'User'])); // true
+     * console.log(trail.includes(['schemas', 'Product'])); // false
+     * console.log(trail.includes(['components'])); // true
+     * ```
+     */
     includes(frames: string[]): boolean;
+    /**
+     * Gets a copy of the current stack frames.
+     *
+     * @returns Array of stack frames in order
+     *
+     * @example
+     * ```typescript
+     * const trail = new StackTrail(['components', 'schemas', 'User']);
+     * const frames = trail.stackTrail;
+     * console.log(frames); // ['components', 'schemas', 'User']
+     * ```
+     */
     get stackTrail(): string[];
+    /**
+     * Appends frame(s) to the end of the trail.
+     *
+     * @param frame - Single frame string or array of frames to append
+     * @returns This StackTrail instance for chaining
+     *
+     * @throws {Error} When frame is not a string or string array
+     *
+     * @example Single frame
+     * ```typescript
+     * const trail = new StackTrail(['components']);
+     * trail.append('schemas').append('User');
+     * console.log(trail.toString()); // 'components:schemas:User'
+     * ```
+     *
+     * @example Multiple frames
+     * ```typescript
+     * const trail = new StackTrail();
+     * trail.append(['components', 'schemas', 'User']);
+     * console.log(trail.toString()); // 'components:schemas:User'
+     * ```
+     */
     append(frame: string | string[]): StackTrail;
+    /**
+     * Gets the parent name of a property frame.
+     *
+     * This method is specifically designed to find parent object names
+     * for property trails in schema processing.
+     *
+     * @param frame - The frame name to find the parent of
+     * @returns Parent name if found, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * const trail = new StackTrail(['components', 'schemas', 'User', 'properties', 'email']);
+     * const parent = trail.getParentOf('email');
+     * console.log(parent); // 'User'
+     * ```
+     */
     getParentOf(frame: string): string | undefined;
+    /**
+     * Converts the trail to an OpenAPI reference string if applicable.
+     *
+     * Only trails that represent valid OpenAPI component references
+     * (starting with 'components') can be converted to reference strings.
+     *
+     * @returns OpenAPI reference string or undefined if not a valid reference trail
+     *
+     * @example Valid reference trail
+     * ```typescript
+     * const trail = new StackTrail(['components', 'schemas', 'User']);
+     * const ref = trail.toStackRef();
+     * console.log(ref); // '#/components/schemas/User'
+     * ```
+     *
+     * @example Invalid trail
+     * ```typescript
+     * const trail = new StackTrail(['paths', '/users', 'get']);
+     * const ref = trail.toStackRef();
+     * console.log(ref); // undefined
+     * ```
+     */
     toStackRef(): string | undefined;
+    /**
+     * Removes frame(s) from the end of the trail.
+     *
+     * @param frame - Single frame string or array of frames to remove
+     * @returns This StackTrail instance for chaining
+     *
+     * @throws {Error} When trying to remove a frame that doesn't match the last frame
+     * @throws {Error} When frame is not a string or string array
+     *
+     * @example Single frame removal
+     * ```typescript
+     * const trail = new StackTrail(['components', 'schemas', 'User', 'properties']);
+     * trail.remove('properties');
+     * console.log(trail.toString()); // 'components:schemas:User'
+     * ```
+     *
+     * @example Multiple frame removal
+     * ```typescript
+     * const trail = new StackTrail(['components', 'schemas', 'User', 'properties', 'name']);
+     * trail.remove(['name', 'properties']);
+     * console.log(trail.toString()); // 'components:schemas:User'
+     * ```
+     */
     remove(frame: string | string[]): StackTrail;
+    /**
+     * Joins multiple stacks or strings into a single colon-separated string.
+     *
+     * @param stacks - Array of StackTrail instances or strings to join
+     * @returns Joined string with colon separators
+     *
+     * @example
+     * ```typescript
+     * const trail1 = new StackTrail(['components', 'schemas']);
+     * const trail2 = new StackTrail(['User', 'properties']);
+     *
+     * const joined = StackTrail.join(trail1, 'separator', trail2);
+     * console.log(joined); // 'components:schemas:separator:User:properties'
+     * ```
+     */
     static join(...stacks: (StackTrail | string)[]): string;
+    /**
+     * Parses a colon-separated string into a StackTrail instance.
+     *
+     * @param value - Colon-separated string to parse
+     * @returns New StackTrail instance
+     *
+     * @throws {Error} When the string contains empty tokens
+     *
+     * @example
+     * ```typescript
+     * const trail = StackTrail.parse('components:schemas:User:properties:name');
+     * console.log(trail.stackTrail); // ['components', 'schemas', 'User', 'properties', 'name']
+     *
+     * // Handles escaped colons
+     * const escapedTrail = StackTrail.parse('components:schemas:User%3AType');
+     * console.log(escapedTrail.stackTrail); // ['components', 'schemas', 'User:Type']
+     * ```
+     */
     static parse(value: string): StackTrail;
+    /**
+     * Converts the trail to JSON representation.
+     *
+     * Used for serialization in JSON contexts. Returns the same
+     * as toString() method.
+     *
+     * @returns String representation of the trail
+     *
+     * @example
+     * ```typescript
+     * const trail = new StackTrail(['components', 'schemas', 'User']);
+     * const json = JSON.stringify({ path: trail });
+     * console.log(json); // '{"path":"components:schemas:User"}'
+     * ```
+     */
     toJSON(): string;
+    /**
+     * Converts the trail to a colon-separated string representation.
+     *
+     * Colons within frame names are escaped as '%3A' to avoid conflicts
+     * with the separator character.
+     *
+     * @returns String representation of the trail
+     *
+     * @example
+     * ```typescript
+     * const trail = new StackTrail(['components', 'schemas', 'User']);
+     * console.log(trail.toString()); // 'components:schemas:User'
+     *
+     * // With colon in frame name
+     * const trailWithColon = new StackTrail(['components', 'schemas', 'User:Type']);
+     * console.log(trailWithColon.toString()); // 'components:schemas:User%3AType'
+     * ```
+     */
     toString(): string;
 }
 //# sourceMappingURL=StackTrail.d.ts.map

package/script/context/StackTrail.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StackTrail.d.ts","sourceRoot":"","sources":["../../src/context/StackTrail.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAG9B,qBAAa,UAAU;;gBAGT,KAAK,GAAE,MAAM,EAAO;IAIhC,KAAK,IAAI,UAAU;IAInB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,UAAU;IAI9C,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO;IAInC,IAAI,UAAU,IAAI,MAAM,EAAE,CAEzB;IAED,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU;IAgB5C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAW9C,UAAU,IAAI,MAAM,GAAG,SAAS;IAkBhC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU;IAsB5C,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,EAAE,CAAC,UAAU,GAAG,MAAM,CAAC,EAAE,GAAG,MAAM;IAIvD,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU;IAYvC,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,MAAM;CAOnB"}
+{"version":3,"file":"StackTrail.d.ts","sourceRoot":"","sources":["../../src/context/StackTrail.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAG9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,qBAAa,UAAU;;IAIrB;;;;;;;;;;;;;OAaG;gBACS,KAAK,GAAE,MAAM,EAAO;IAIhC;;;;;;;;;;;;;;OAcG;IACH,KAAK,IAAI,UAAU;IAInB;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,UAAU;IAI9C;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO;IAInC;;;;;;;;;;;OAWG;IACH,IAAI,UAAU,IAAI,MAAM,EAAE,CAEzB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU;IAgB5C;;;;;;;;;;;;;;;OAeG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAW9C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,UAAU,IAAI,MAAM,GAAG,SAAS;IAkBhC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU;IAsB5C;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,EAAE,CAAC,UAAU,GAAG,MAAM,CAAC,EAAE,GAAG,MAAM;IAIvD;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU;IAYvC;;;;;;;;;;;;;;OAcG;IACH,MAAM,IAAI,MAAM;IAIhB;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,IAAI,MAAM;CAOnB"}