diff --git a/.eslintrc.json b/.eslintrc.json
new file mode 100644
index 0000000..a228265
--- /dev/null
+++ b/.eslintrc.json
@@ -0,0 +1,24 @@
+{
+ "env": {
+ "browser": true,
+ "es2021": true,
+ "node": true
+ },
+ "extends": [
+ "eslint:recommended"
+ ],
+ "parser": "@typescript-eslint/parser",
+ "parserOptions": {
+ "ecmaVersion": "latest",
+ "sourceType": "module"
+ },
+ "plugins": [
+ "@typescript-eslint"
+ ],
+ "rules": {
+ "@typescript-eslint/no-unused-vars": "off",
+ "@typescript-eslint/no-explicit-any": "off",
+ "no-unused-vars": "off"
+ },
+ "ignorePatterns": ["dist/", "node_modules/", "coverage/"]
+}
\ No newline at end of file
diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml
new file mode 100644
index 0000000..e53ad25
--- /dev/null
+++ b/.github/workflows/deploy-docs.yml
@@ -0,0 +1,85 @@
+name: Deploy Documentation to GitHub Pages
+
+on:
+ push:
+ branches: [ main, copilot/fix-1 ]
+ pull_request:
+ branches: [ main ]
+ workflow_dispatch:
+
+permissions:
+ contents: read
+ pages: write
+ id-token: write
+
+concurrency:
+ group: "pages"
+ cancel-in-progress: false
+
+jobs:
+ build-and-deploy:
+ runs-on: ubuntu-latest
+ environment:
+ name: github-pages
+ url: ${{ steps.deployment.outputs.page_url }}
+
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@v4
+ with:
+ token: ${{ secrets.GITHUB_TOKEN }}
+
+ - name: Setup Node.js
+ uses: actions/setup-node@v4
+ with:
+ node-version: '18'
+ cache: 'npm'
+
+ - name: Install dependencies
+ run: npm ci
+
+ - name: Build documentation
+ run: |
+ mkdir -p dist
+ cp README.md dist/
+ cp -r docs/ dist/
+ cp packages/fmlrunner-rest/openapi.yaml dist/
+ echo "# FML Runner Documentation" > dist/index.html
+ echo "Available Documentation:
" >> dist/index.html
+ echo "" >> dist/index.html
+
+ - name: Setup Pages
+ uses: actions/configure-pages@v4
+ with:
+ enablement: true
+ continue-on-error: true
+
+ - name: Upload artifact
+ uses: actions/upload-pages-artifact@v3
+ with:
+ path: 'dist'
+ continue-on-error: true
+
+ - name: Deploy to GitHub Pages
+ id: deployment
+ uses: actions/deploy-pages@v4
+ if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/copilot/fix-1'
+ continue-on-error: true
+
+ - name: Pages deployment status
+ if: failure()
+ run: |
+ echo "GitHub Pages deployment failed. This is likely because:"
+ echo "1. GitHub Pages is not enabled for this repository"
+ echo "2. Pages is not configured to use GitHub Actions as the source"
+ echo ""
+ echo "To fix this:"
+ echo "1. Go to repository Settings > Pages"
+ echo "2. Under 'Build and deployment', select 'GitHub Actions' as the source"
+ echo "3. Re-run this workflow"
+ echo ""
+ echo "The documentation files have still been built and are available in the workflow artifacts."
\ No newline at end of file
diff --git a/.github/workflows/publish-npm.yml b/.github/workflows/publish-npm.yml
new file mode 100644
index 0000000..a9792ea
--- /dev/null
+++ b/.github/workflows/publish-npm.yml
@@ -0,0 +1,202 @@
+name: Publish to NPM
+
+on:
+ release:
+ types: [published]
+ workflow_dispatch:
+ inputs:
+ version_type:
+ description: 'Version increment type'
+ required: true
+ default: 'patch'
+ type: choice
+ options:
+ - patch
+ - minor
+ - major
+ publish_to_npm:
+ description: 'Publish to NPM registry'
+ required: true
+ default: true
+ type: boolean
+ dry_run:
+ description: 'Dry run (test publishing without actually publishing)'
+ required: true
+ default: false
+ type: boolean
+
+permissions:
+ contents: write
+ id-token: write
+
+jobs:
+ publish:
+ runs-on: ubuntu-latest
+ environment: npm-publishing
+
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@v4
+ with:
+ token: ${{ secrets.GITHUB_TOKEN }}
+ fetch-depth: 0
+
+ - name: Setup Node.js
+ uses: actions/setup-node@v4
+ with:
+ node-version: '18'
+ cache: 'npm'
+ registry-url: 'https://registry.npmjs.org'
+
+ - name: Install dependencies
+ run: npm ci
+
+ - name: Configure Git
+ run: |
+ git config --global user.name 'github-actions[bot]'
+ git config --global user.email 'github-actions[bot]@users.noreply.github.com'
+
+ - name: Update package versions
+ if: github.event_name == 'workflow_dispatch'
+ run: |
+ echo "Updating versions with type: ${{ github.event.inputs.version_type }}"
+ node scripts/version.js bump ${{ github.event.inputs.version_type }}
+
+ NEW_VERSION=$(node scripts/version.js current)
+ echo "New version: $NEW_VERSION"
+ echo "NEW_VERSION=$NEW_VERSION" >> $GITHUB_ENV
+
+ - name: Extract version from release
+ if: github.event_name == 'release'
+ run: |
+ RELEASE_VERSION="${{ github.event.release.tag_name }}"
+ # Remove 'v' prefix if present
+ VERSION=${RELEASE_VERSION#v}
+ echo "Setting version to: $VERSION"
+
+ node scripts/version.js set $VERSION
+ echo "NEW_VERSION=$VERSION" >> $GITHUB_ENV
+
+ - name: Run quality checks
+ run: |
+ echo "Running linting..."
+ npm run lint
+
+ echo "Running tests..."
+ npm run test
+
+ echo "Building packages..."
+ npm run build
+
+ - name: Verify package contents
+ run: |
+ echo "=== Package Contents Verification ==="
+ for pkg in packages/*/; do
+ echo "Checking $pkg..."
+ cd "$pkg"
+ npm pack --dry-run
+ cd ../..
+ done
+
+ - name: Publish packages (dry run)
+ if: github.event.inputs.dry_run == 'true'
+ run: |
+ echo "=== DRY RUN: Publishing packages ==="
+ node scripts/version.js publish --dry-run
+ env:
+ NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+ - name: Publish packages to NPM
+ if: github.event.inputs.publish_to_npm == 'true' && github.event.inputs.dry_run != 'true'
+ run: |
+ echo "=== Publishing packages to NPM ==="
+ node scripts/version.js publish
+ env:
+ NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+ - name: Commit version changes
+ if: github.event_name == 'workflow_dispatch' && github.event.inputs.dry_run != 'true'
+ run: |
+ git add .
+ git commit -m "chore: bump version to ${{ env.NEW_VERSION }}" || echo "No changes to commit"
+ git tag "v${{ env.NEW_VERSION }}"
+ git push origin HEAD --tags
+
+ - name: Create GitHub Release
+ if: github.event_name == 'workflow_dispatch' && github.event.inputs.publish_to_npm == 'true' && github.event.inputs.dry_run != 'true'
+ uses: actions/create-release@v1
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ with:
+ tag_name: "v${{ env.NEW_VERSION }}"
+ release_name: "Release v${{ env.NEW_VERSION }}"
+ body: |
+ ## Release v${{ env.NEW_VERSION }}
+
+ Published packages to NPM:
+ - ๐ฆ [fmlrunner@${{ env.NEW_VERSION }}](https://www.npmjs.com/package/fmlrunner)
+ - ๐ฆ [fmlrunner-rest@${{ env.NEW_VERSION }}](https://www.npmjs.com/package/fmlrunner-rest)
+ - ๐ฆ [fmlrunner-mcp@${{ env.NEW_VERSION }}](https://www.npmjs.com/package/fmlrunner-mcp)
+ - ๐ฆ [fmlrunner-web@${{ env.NEW_VERSION }}](https://www.npmjs.com/package/fmlrunner-web)
+
+ ### Installation
+ ```bash
+ npm install fmlrunner
+ npm install -g fmlrunner-rest
+ npm install -g fmlrunner-mcp
+ ```
+
+ ### Changes
+ - Version bump: ${{ github.event.inputs.version_type }}
+ - All packages updated to v${{ env.NEW_VERSION }}
+ draft: false
+ prerelease: false
+
+ - name: Generate Publishing Summary
+ if: always()
+ run: |
+ echo "## NPM Publishing Summary" >> $GITHUB_STEP_SUMMARY
+ echo "" >> $GITHUB_STEP_SUMMARY
+
+ if [ "${{ github.event.inputs.dry_run }}" == "true" ]; then
+ echo "๐งช **Mode:** Dry Run (no actual publishing)" >> $GITHUB_STEP_SUMMARY
+ elif [ "${{ github.event.inputs.publish_to_npm }}" == "true" ]; then
+ echo "๐ฆ **Mode:** Published to NPM Registry" >> $GITHUB_STEP_SUMMARY
+ else
+ echo "๐ **Mode:** Build and Test Only" >> $GITHUB_STEP_SUMMARY
+ fi
+
+ echo "" >> $GITHUB_STEP_SUMMARY
+ echo "| Package | Version | Status |" >> $GITHUB_STEP_SUMMARY
+ echo "|---------|---------|--------|" >> $GITHUB_STEP_SUMMARY
+
+ for pkg in fmlrunner fmlrunner-rest fmlrunner-mcp fmlrunner-web; do
+ version=$(node -p "require('./packages/$pkg/package.json').version" 2>/dev/null || echo "unknown")
+ if [ "${{ job.status }}" == "success" ]; then
+ echo "| $pkg | $version | โ
Success |" >> $GITHUB_STEP_SUMMARY
+ else
+ echo "| $pkg | $version | โ Failed |" >> $GITHUB_STEP_SUMMARY
+ fi
+ done
+
+ echo "" >> $GITHUB_STEP_SUMMARY
+
+ if [ "${{ github.event.inputs.publish_to_npm }}" == "true" ] && [ "${{ github.event.inputs.dry_run }}" != "true" ] && [ "${{ job.status }}" == "success" ]; then
+ echo "### ๐ Packages Available" >> $GITHUB_STEP_SUMMARY
+ echo "- [fmlrunner](https://www.npmjs.com/package/fmlrunner)" >> $GITHUB_STEP_SUMMARY
+ echo "- [fmlrunner-rest](https://www.npmjs.com/package/fmlrunner-rest)" >> $GITHUB_STEP_SUMMARY
+ echo "- [fmlrunner-mcp](https://www.npmjs.com/package/fmlrunner-mcp)" >> $GITHUB_STEP_SUMMARY
+ echo "- [fmlrunner-web](https://www.npmjs.com/package/fmlrunner-web)" >> $GITHUB_STEP_SUMMARY
+ fi
+
+ notify:
+ needs: publish
+ runs-on: ubuntu-latest
+ if: always() && needs.publish.result == 'success' && github.event.inputs.publish_to_npm == 'true' && github.event.inputs.dry_run != 'true'
+
+ steps:
+ - name: Notify Success
+ run: |
+ echo "โ
Successfully published FML Runner packages to NPM!"
+ echo "Version: ${{ env.NEW_VERSION }}"
+ echo "Packages: fmlrunner, fmlrunner-rest, fmlrunner-mcp, fmlrunner-web"
\ No newline at end of file
diff --git a/.github/workflows/qa.yml b/.github/workflows/qa.yml
new file mode 100644
index 0000000..b5d9bd2
--- /dev/null
+++ b/.github/workflows/qa.yml
@@ -0,0 +1,284 @@
+name: QA Report
+
+on:
+ pull_request:
+ branches: [ main, develop ]
+ push:
+ branches: [ main, develop ]
+
+jobs:
+ qa-report:
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix:
+ node-version: [16, 18, 20]
+
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@v4
+
+ - name: Setup Node.js ${{ matrix.node-version }}
+ uses: actions/setup-node@v4
+ with:
+ node-version: ${{ matrix.node-version }}
+ cache: 'npm'
+
+ - name: Install dependencies
+ run: npm ci
+
+ - name: Run linting
+ id: lint
+ continue-on-error: true
+ run: |
+ npm run lint 2>&1 | tee lint-output.txt
+
+ - name: Build project
+ id: build
+ continue-on-error: true
+ run: |
+ npm run build 2>&1 | tee build-output.txt
+
+ - name: Run tests with coverage
+ id: coverage
+ continue-on-error: true
+ run: |
+ ./node_modules/.bin/jest --testMatch="**/tests/**/*.test.ts" --coverage --coverageReporters=text-lcov 2>&1 | tee coverage-output.txt
+
+ - name: FML Compilation Tests
+ id: fml-compilation
+ continue-on-error: true
+ run: |
+ echo "=== FML Compilation Test Results ==="
+ ./node_modules/.bin/jest --testMatch="**/tests/**/*.test.ts" --testPathPattern="fml-compiler|fhir-mapping-language" --verbose 2>&1 | tee fml-compilation-output.txt
+
+ - name: FML Execution Tests
+ id: fml-execution
+ continue-on-error: true
+ run: |
+ echo "=== FML Execution Test Results ==="
+ ./node_modules/.bin/jest --testMatch="**/tests/**/*.test.ts" --testPathPattern="structure-map-executor|fhirpath-integration" --verbose 2>&1 | tee fml-execution-output.txt
+
+ - name: FHIR API Tests
+ id: fhir-api
+ continue-on-error: true
+ run: |
+ echo "=== FHIR API Test Results ==="
+ ./node_modules/.bin/jest --testMatch="**/tests/**/*.test.ts" --testPathPattern="api|enhanced-api" --verbose 2>&1 | tee fhir-api-output.txt
+
+ - name: Validation & Core Tests
+ id: validation-core
+ continue-on-error: true
+ run: |
+ echo "=== Validation & Core Test Results ==="
+ ./node_modules/.bin/jest --testMatch="**/tests/**/*.test.ts" --testPathPattern="validation-service|fml-runner|structure-map-retriever|enhanced-tokenizer" --verbose 2>&1 | tee validation-core-output.txt
+
+ - name: Generate QA Summary Table and Post PR Comment
+ if: always()
+ uses: actions/github-script@v7
+ with:
+ script: |
+ const fs = require('fs');
+
+ // Helper function to read file safely
+ function readOutputFile(filename) {
+ try {
+ if (fs.existsSync(filename)) {
+ return fs.readFileSync(filename, 'utf8');
+ }
+ return '';
+ } catch (error) {
+ return `Error reading ${filename}: ${error.message}`;
+ }
+ }
+
+ // Helper function to extract error context from output
+ function extractErrorContext(output, maxLines = 10) {
+ if (!output) return 'No output captured';
+
+ const lines = output.split('\n');
+ const errorLines = [];
+ let capturing = false;
+
+ for (let i = 0; i < lines.length && errorLines.length < maxLines; i++) {
+ const line = lines[i];
+
+ // Look for error indicators
+ if (line.includes('FAIL') || line.includes('Error:') || line.includes('Failed:') ||
+ line.includes('โ ') || line.includes('โ') || line.includes('ERRORS:')) {
+ capturing = true;
+ }
+
+ if (capturing) {
+ errorLines.push(line);
+ // Stop capturing after finding summary or next test
+ if (line.includes('Test Suites:') || line.includes('Tests:')) {
+ break;
+ }
+ }
+ }
+
+ return errorLines.length > 0 ? errorLines.slice(0, maxLines).join('\n') : 'No specific error details captured';
+ }
+
+ // Get step outcomes
+ const outcomes = {
+ lint: '${{ steps.lint.outcome }}',
+ build: '${{ steps.build.outcome }}',
+ coverage: '${{ steps.coverage.outcome }}',
+ fmlCompilation: '${{ steps.fml-compilation.outcome }}',
+ fmlExecution: '${{ steps.fml-execution.outcome }}',
+ fhirApi: '${{ steps.fhir-api.outcome }}',
+ validationCore: '${{ steps.validation-core.outcome }}'
+ };
+
+ // Read output files
+ const outputs = {
+ lint: readOutputFile('lint-output.txt'),
+ build: readOutputFile('build-output.txt'),
+ coverage: readOutputFile('coverage-output.txt'),
+ fmlCompilation: readOutputFile('fml-compilation-output.txt'),
+ fmlExecution: readOutputFile('fml-execution-output.txt'),
+ fhirApi: readOutputFile('fhir-api-output.txt'),
+ validationCore: readOutputFile('validation-core-output.txt')
+ };
+
+ // Extract test summary from coverage output
+ const coverageOutput = outputs.coverage;
+ let totalTests = 'unknown';
+ let totalSuites = 'unknown';
+
+ const testMatch = coverageOutput.match(/Tests:\s*(\d+\s+\w+)/);
+ const suiteMatch = coverageOutput.match(/Test Suites:\s*(\d+\s+\w+)/);
+
+ if (testMatch) totalTests = testMatch[1];
+ if (suiteMatch) totalSuites = suiteMatch[1];
+
+ // Build QA table
+ let qaTable = `## QA Report Summary - Node.js ${{ matrix.node-version }}
+
+| Test Category | Status | Details | Error Context |
+|---------------|--------|---------|---------------|`;
+
+ // Build Status
+ if (outcomes.build === 'success') {
+ qaTable += `\n| Build | โ
Passed | TypeScript compilation successful | - |`;
+ } else {
+ const errorContext = extractErrorContext(outputs.build, 5);
+ qaTable += `\n| Build | โ Failed | TypeScript compilation failed | \`\`\`\n${errorContext}\n\`\`\` |`;
+ }
+
+ // Linting Status
+ if (outcomes.lint === 'success') {
+ qaTable += `\n| Linting | โ
Passed | ESLint validation successful | - |`;
+ } else {
+ const errorContext = extractErrorContext(outputs.lint, 5);
+ qaTable += `\n| Linting | โ Failed | ESLint validation failed | \`\`\`\n${errorContext}\n\`\`\` |`;
+ }
+
+ // FML Compilation Tests
+ if (outcomes.fmlCompilation === 'success') {
+ qaTable += `\n| FML Compilation | โ
Passed | FML parsing and compilation tests | - |`;
+ } else {
+ const errorContext = extractErrorContext(outputs.fmlCompilation, 8);
+ qaTable += `\n| FML Compilation | โ Failed | FML parsing and compilation tests | \`\`\`\n${errorContext}\n\`\`\` |`;
+ }
+
+ // FML Execution Tests
+ if (outcomes.fmlExecution === 'success') {
+ qaTable += `\n| FML Execution | โ
Passed | StructureMap execution and FHIRPath tests | - |`;
+ } else {
+ const errorContext = extractErrorContext(outputs.fmlExecution, 8);
+ qaTable += `\n| FML Execution | โ Failed | StructureMap execution and FHIRPath tests | \`\`\`\n${errorContext}\n\`\`\` |`;
+ }
+
+ // FHIR API Tests
+ if (outcomes.fhirApi === 'success') {
+ qaTable += `\n| FHIR API | โ
Passed | REST API endpoints and CRUD operations | - |`;
+ } else {
+ const errorContext = extractErrorContext(outputs.fhirApi, 8);
+ qaTable += `\n| FHIR API | โ Failed | REST API endpoints and CRUD operations | \`\`\`\n${errorContext}\n\`\`\` |`;
+ }
+
+ // Validation & Core Tests
+ if (outcomes.validationCore === 'success') {
+ qaTable += `\n| Validation & Core | โ
Passed | Input validation and core library functions | - |`;
+ } else {
+ const errorContext = extractErrorContext(outputs.validationCore, 8);
+ qaTable += `\n| Validation & Core | โ Failed | Input validation and core library functions | \`\`\`\n${errorContext}\n\`\`\` |`;
+ }
+
+ // Overall Summary
+ const overallStatus = Object.values(outcomes).every(outcome => outcome === 'success') ? 'โ
All QA checks passed' : 'โ Some QA checks failed';
+
+ qaTable += `
+
+### Summary
+- **Node.js Version:** ${{ matrix.node-version }}
+- **Total Tests:** ${totalTests}
+- **Test Suites:** ${totalSuites}
+- **Overall Status:** ${overallStatus}
+
+
+๐ View Full Test Output
+
+**Coverage Output:**
+\`\`\`
+${outputs.coverage.split('\n').slice(-20).join('\n')}
+\`\`\`
+
+ `;
+
+ // Post comment to PR if this is a pull request
+ if (context.eventName === 'pull_request') {
+ try {
+ // Check if a comment already exists from this workflow
+ const { data: comments } = await github.rest.issues.listComments({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ issue_number: context.issue.number,
+ });
+
+ const existingComment = comments.find(comment =>
+ comment.user.login === 'github-actions[bot]' &&
+ comment.body.includes(`QA Report Summary - Node.js ${{ matrix.node-version }}`)
+ );
+
+ if (existingComment) {
+ // Update existing comment
+ await github.rest.issues.updateComment({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ comment_id: existingComment.id,
+ body: qaTable
+ });
+ console.log('Updated existing QA report comment');
+ } else {
+ // Create new comment
+ await github.rest.issues.createComment({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ issue_number: context.issue.number,
+ body: qaTable
+ });
+ console.log('Created new QA report comment');
+ }
+ } catch (error) {
+ console.error('Error posting PR comment:', error);
+ // Fall back to step summary
+ core.summary.addRaw(qaTable).write();
+ }
+ } else {
+ // For push events, just write to step summary
+ core.summary.addRaw(qaTable).write();
+ }
+
+ - name: Upload test artifacts
+ uses: actions/upload-artifact@v4
+ if: always()
+ with:
+ name: test-results-node-${{ matrix.node-version }}
+ path: |
+ coverage/
+ dist/
+ *-output.txt
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..012e10a
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,135 @@
+# Dependencies
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage/
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+jspm_packages/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+public
+
+# Vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
+
+# Build output
+dist/
+build/
+
+# Test output
+test-results/
+coverage/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Temporary files
+tmp/
+temp/node_modules/
+packages/fmlrunner-web-REMOVED/
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..3e4ce22
--- /dev/null
+++ b/README.md
@@ -0,0 +1,300 @@
+# FML Runner
+
+A Node.js library for compiling and executing FHIR Mapping Language (FML) files to transform healthcare data using FHIR StructureMaps.
+
+## Overview
+
+FML Runner is designed as a library component for larger application frameworks, providing comprehensive functionality to:
+
+1. **Compile** FHIR Mapping Language (FML) content into FHIR StructureMap resources (JSON format)
+2. **Execute** StructureMaps on input content to perform data transformations
+3. **Manage** FHIR terminology resources (ConceptMaps, ValueSets, CodeSystems, StructureDefinitions)
+4. **Process** FHIR Bundles for bulk resource operations
+5. **Provide** REST API endpoints with FHIR-compliant CRUD operations
+6. **Optimize** performance with intelligent caching and FHIRPath integration
+
+## Installation
+
+### Prerequisites
+
+- **Node.js**: v16.0.0 or higher
+- **npm**: v8.0.0 or higher
+
+### Install from npm (Production)
+
+**Core Library:**
+```bash
+npm install fmlrunner
+```
+
+**REST API Server:**
+```bash
+npm install -g fmlrunner-rest
+```
+
+**Model Context Protocol Interface:**
+```bash
+npm install -g fmlrunner-mcp
+```
+
+**Web Interface:**
+```bash
+npm install fmlrunner-web
+```
+
+### Package Overview
+
+| Package | Description | Status |
+|---------|-------------|--------|
+| [`fmlrunner`](https://www.npmjs.com/package/fmlrunner) | Core FML library for compilation and execution | [](https://www.npmjs.com/package/fmlrunner) |
+| [`fmlrunner-rest`](https://www.npmjs.com/package/fmlrunner-rest) | REST API server with FHIR endpoints | [](https://www.npmjs.com/package/fmlrunner-rest) |
+| [`fmlrunner-mcp`](https://www.npmjs.com/package/fmlrunner-mcp) | Model Context Protocol interface for AI tools | [](https://www.npmjs.com/package/fmlrunner-mcp) |
+| [`fmlrunner-web`](https://www.npmjs.com/package/fmlrunner-web) | React web interface and documentation | [](https://www.npmjs.com/package/fmlrunner-web) |
+
+### Install from Source (Development)
+
+```bash
+# Clone the repository
+git clone https://github.com/litlfred/fmlrunner.git
+cd fmlrunner
+
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Run tests
+npm test
+```
+
+### Quick Start
+
+#### Library Usage
+
+```javascript
+import { FmlRunner } from 'fml-runner';
+
+const runner = new FmlRunner();
+
+// Compile FML to StructureMap
+const fmlContent = `
+map "http://example.org/PatientMapping" = "PatientMapping"
+uses "http://hl7.org/fhir/StructureDefinition/QuestionnaireResponse" alias QR as source
+uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as target
+
+group QuestionnaireResponse(source src : QR, target tgt : Patient) {
+ src.item as item -> tgt.gender = 'unknown';
+}
+`;
+
+const structureMap = await runner.compileStructureMap(fmlContent);
+
+// Execute transformation
+const inputData = { resourceType: "QuestionnaireResponse", status: "completed" };
+const result = await runner.executeStructureMap(structureMap.url, inputData);
+```
+
+#### REST API Server
+
+```bash
+# Start server with default settings
+npm start
+
+# Start with custom port and base URL
+npm start -- --port 8080 --base-url ./my-maps
+
+# Or using environment variables
+PORT=8080 BASE_URL=./my-maps npm start
+```
+
+The REST API will be available at `http://localhost:8080` with endpoints:
+- `POST /StructureMap/` - Upload StructureMap
+- `GET /StructureMap/{id}` - Retrieve StructureMap
+- `POST /StructureMap/$transform` - Transform data
+- `POST /Bundle` - Bulk resource upload
+- Full CRUD for ConceptMap, ValueSet, CodeSystem, StructureDefinition
+
+## Key Features
+
+### FHIR Mapping Language Support
+- **Complete FML parser** with proper tokenization and grammar handling
+- **Preamble support** including ConceptMap declarations, Prefix statements
+- **Enhanced comment handling** (single-line, multi-line, documentation)
+- **Robust parsing** with graceful error recovery
+
+### FHIR Terminology Ecosystem
+- **ConceptMap operations**: CRUD + `$translate` with equivalence mapping
+- **ValueSet operations**: CRUD + `$expand`, `$validate-code`
+- **CodeSystem operations**: CRUD + `$lookup`, `$subsumes`, `$validate-code`
+- **StructureDefinition management**: Logical models and profiles
+- **Bundle processing**: Bulk resource operations
+
+### Advanced Execution Engine
+- **Official FHIRPath integration** using HL7 FHIRPath library v4.6.0
+- **Terminology-aware transformations** with ConceptMap integration
+- **Validation support** with strict/non-strict execution modes
+- **Memory-efficient caching** for repeated executions
+
+### Developer Experience
+- **Library + REST API**: Use programmatically or via HTTP endpoints
+- **TypeScript support**: Full type definitions included
+- **Comprehensive testing**: 108 tests covering all functionality
+- **OpenAPI documentation**: Complete API specification
+
+## Development
+
+### Project Structure
+
+```
+fmlrunner/
+โโโ src/ # Source code
+โ โโโ api/ # REST API server implementation
+โ โโโ lib/ # Core library components
+โ โโโ types/ # TypeScript type definitions
+โ โโโ index.ts # Main library entry point
+โ โโโ server.ts # REST API server entry point
+โโโ tests/ # Test suites
+โโโ docs/ # Documentation
+โโโ dist/ # Compiled output (generated)
+```
+
+### Development Commands
+
+```bash
+# Install dependencies
+npm install
+
+# Build TypeScript to JavaScript
+npm run build
+
+# Run tests
+npm test
+
+# Run linting
+npm run lint
+
+# Start development server
+npm run dev
+
+# Clean build artifacts
+npm run clean
+```
+
+### Testing
+
+The project includes comprehensive test coverage across:
+
+- **FML Compilation Tests**: Parser validation and StructureMap generation
+- **Execution Tests**: Transformation logic and FHIRPath integration
+- **API Tests**: REST endpoint functionality and FHIR compliance
+- **Terminology Tests**: ConceptMap, ValueSet, CodeSystem operations
+- **Integration Tests**: End-to-end workflows and bundle processing
+
+Run specific test suites:
+```bash
+# Run FML compilation tests
+npm test -- --testNamePattern="FML.*compilation"
+
+# Run execution tests
+npm test -- --testNamePattern="execution|execute"
+
+# Run API tests
+npm test -- --testNamePattern="API|endpoint"
+```
+
+## Documentation
+
+Comprehensive documentation is available in the `docs/` directory:
+
+- [`REQUIREMENTS.md`](./docs/REQUIREMENTS.md) - Complete functional requirements
+- [`api.yaml`](./docs/api.yaml) - OpenAPI 3.0 specification for all endpoints
+
+## API Reference
+
+### Library Methods
+
+```javascript
+// Core compilation and execution
+await runner.compileStructureMap(fmlContent)
+await runner.executeStructureMap(url, inputData)
+
+// Resource management
+await runner.registerConceptMap(conceptMap)
+await runner.registerValueSet(valueSet)
+await runner.registerCodeSystem(codeSystem)
+await runner.registerStructureDefinition(structureDefinition)
+
+// Bundle operations
+await runner.processBundle(bundle)
+await runner.getBundleStats()
+
+// Terminology operations
+await runner.translateCode(system, code, targetSystem)
+await runner.validateCodeInValueSet(code, valueSetUrl)
+await runner.expandValueSet(valueSetUrl)
+await runner.lookupConcept(system, code)
+```
+
+### REST API Endpoints
+
+#### Core StructureMap Operations
+- `POST /StructureMap/` - Create StructureMap
+- `GET /StructureMap/{id}` - Get StructureMap
+- `PUT /StructureMap/{id}` - Update StructureMap
+- `DELETE /StructureMap/{id}` - Delete StructureMap
+- `POST /StructureMap/$transform` - Transform data
+
+#### Terminology Resources
+- `/ConceptMap/` - Full CRUD + `$translate`
+- `/ValueSet/` - Full CRUD + `$expand`, `$validate-code`
+- `/CodeSystem/` - Full CRUD + `$lookup`, `$subsumes`, `$validate-code`
+- `/StructureDefinition/` - Full CRUD for logical models
+
+#### Bundle Operations
+- `POST /Bundle` - Bulk resource upload
+- `GET /Bundle/summary` - Resource statistics
+
+## Configuration
+
+### Command Line Options
+
+```bash
+# Server configuration
+--port, -p # Server port (default: 3000)
+--base-url, -b # StructureMap base directory
+--help, -h # Show help
+
+# Example
+node dist/server.js --port 8080 --base-url ./maps
+```
+
+### Environment Variables
+
+```bash
+PORT=3000 # Server listening port
+BASE_URL=./test-data # Base directory for StructureMap files
+```
+
+## Implementation Status
+
+โ
**Complete implementation** with all requested features:
+- Robust FML parser with complete preamble support
+- FHIR-compliant REST API with singular resource naming
+- Official FHIRPath library integration (v4.6.0)
+- Comprehensive terminology ecosystem
+- Bundle processing capabilities
+- Library API exposure (80+ methods)
+- Validation framework with strict/non-strict modes
+- Command line configuration
+- JSON-only format enforcement
+
+**Test Results**: 108/108 tests passing across 10 test suites
+
+## License
+
+MIT License - see [LICENSE](./LICENSE) file for details.
+
+## Contributing
+
+Please refer to the requirements documents in the `docs/` directory for implementation guidelines and specifications. All contributions should maintain the existing test coverage and follow the established coding patterns.
\ No newline at end of file
diff --git a/docs/FUNCTIONAL_REQUIREMENTS.md b/docs/FUNCTIONAL_REQUIREMENTS.md
new file mode 100644
index 0000000..0ef4b12
--- /dev/null
+++ b/docs/FUNCTIONAL_REQUIREMENTS.md
@@ -0,0 +1,267 @@
+# FML Runner - Complete Functional Requirements
+
+This document synthesizes the complete functional requirements for the FML Runner library, derived from the original issue description and all subsequent feature requests from PR comments.
+
+## Core Architecture
+
+### FR-001: Library Design Philosophy
+- **Primary Purpose**: Library component for larger application frameworks
+- **Dual Interface**: Both programmatic API and REST endpoints
+- **Lean Implementation**: Expose only essential external APIs for requested functions
+- **No Configuration Management**: Keep library lean without complex configuration systems
+- **Public Assets Assumption**: All assets are public (no authentication required)
+
+### FR-002: FHIR Compliance
+- **FHIR Standards**: Full compliance with FHIR R4 specifications
+- **Resource Naming**: Singular resource names (StructureMap, ConceptMap, etc.)
+- **CRUD Operations**: Standard FHIR CRUD patterns for all resource types
+- **Search Parameters**: Support FHIR search parameters per resource specifications
+- **JSON Format**: JSON-only format enforcement across all endpoints
+
+## FML Processing
+
+### FR-101: FML Compilation
+- **Input Format**: FHIR Mapping Language (FML) source content
+- **Output Format**: FHIR StructureMap resources (JSON)
+- **Parser Requirements**: Robust parsing with proper tokenization and grammar handling
+- **Preamble Support**: Complete support for FML preamble elements:
+ - Map declarations: `map "url" = "name"`
+ - Uses statements: `uses "url" alias Name as mode`
+ - ConceptMap declarations: `conceptmap "url" { ... }`
+ - Prefix declarations: `prefix system = "url"`
+ - Import statements: `imports "url"`
+ - Comment support: Single-line (`//`), multi-line (`/* */`), documentation (`///`)
+- **Error Recovery**: Graceful fallback parsing that extracts URL and name from complex FML files
+- **Validation**: Syntax validation with informative error messages
+
+### FR-102: FML Execution
+- **StructureMap Execution**: Transform input data using compiled StructureMaps
+- **FHIRPath Integration**: Use official HL7 FHIRPath library (v4.6.0) for expression evaluation
+- **Terminology Integration**: Terminology-aware transformations using loaded ConceptMaps
+- **Transform Operations**: Support for all FHIR transform operations including:
+ - `translate` - Code translation using ConceptMaps
+ - `evaluate` - FHIRPath expression evaluation
+ - `create` - Resource creation
+ - `reference` - Reference generation
+ - `dateOp` - Date manipulation
+ - `cast` - Type casting
+- **Validation Modes**:
+ - Strict mode: Fail on validation errors
+ - Non-strict mode: Issue warnings but continue execution
+
+## Resource Management
+
+### FR-201: StructureMap Management
+- **CRUD Operations**: Create, Read, Update, Delete for StructureMaps
+- **File Sources**: Load from local directories and remote URLs
+- **Format Support**: Both compiled JSON StructureMaps and FML source content
+- **Caching**: Simple LRU-based internal caching for performance
+- **Search Parameters**: Support for FHIR StructureMap search parameters:
+ - date, description, identifier, jurisdiction, name, publisher, status, title, url, version
+- **Transform Operation**: `POST /StructureMap/$transform` per FHIR specification
+
+### FR-202: ConceptMap Management
+- **CRUD Operations**: Full Create, Read, Update, Delete operations
+- **Translation Service**: `$translate` operation with equivalence mapping
+- **Search Support**: Standard FHIR ConceptMap search parameters
+- **Integration**: Used by StructureMap executor for terminology-aware transformations
+- **Storage**: Memory-first lookup with persistent storage
+
+### FR-203: ValueSet Management
+- **CRUD Operations**: Full Create, Read, Update, Delete operations
+- **Expansion Service**: `$expand` operation for ValueSet expansion
+- **Validation Service**: `$validate-code` operation for code validation
+- **Search Support**: Standard FHIR ValueSet search parameters
+- **Integration**: Used for validation and terminology operations
+
+### FR-204: CodeSystem Management
+- **CRUD Operations**: Full Create, Read, Update, Delete operations
+- **Lookup Service**: `$lookup` operation for concept details
+- **Subsumption Testing**: `$subsumes` operation for hierarchy relationships
+- **Validation Service**: `$validate-code` operation
+- **Search Support**: Standard FHIR CodeSystem search parameters
+
+### FR-205: StructureDefinition Management
+- **CRUD Operations**: Full Create, Read, Update, Delete operations for logical models
+- **Validation Support**: Runtime validation using StructureDefinitions
+- **Profile Support**: Support for FHIR profiles and extensions
+- **Logical Models**: Support for custom logical models from external sources
+- **Integration**: Used for input/output validation in StructureMap execution
+
+## Bundle Processing
+
+### FR-301: Bundle Operations
+- **Bulk Upload**: `POST /Bundle` endpoint for bulk resource processing
+- **Resource Types**: Support for ConceptMaps, ValueSets, CodeSystems, StructureMaps, StructureDefinitions
+- **Transaction Support**: Process all resources in a Bundle as a unit
+- **Statistics**: Provide Bundle processing statistics and summaries
+- **Validation**: Validate Bundle contents before processing
+
+## API Specifications
+
+### FR-401: REST API Endpoints
+- **Base Path Structure**: Singular resource names following FHIR conventions
+- **StructureMap Endpoints**:
+ - `POST /StructureMap/` - Create StructureMap
+ - `GET /StructureMap/{id}` - Retrieve StructureMap
+ - `PUT /StructureMap/{id}` - Update StructureMap
+ - `DELETE /StructureMap/{id}` - Delete StructureMap
+ - `GET /StructureMap/` - Search StructureMaps
+ - `POST /StructureMap/$transform` - Transform operation
+- **ConceptMap Endpoints**: Full CRUD + `$translate`
+- **ValueSet Endpoints**: Full CRUD + `$expand`, `$validate-code`
+- **CodeSystem Endpoints**: Full CRUD + `$lookup`, `$subsumes`, `$validate-code`
+- **StructureDefinition Endpoints**: Full CRUD
+- **Bundle Endpoints**: `POST /Bundle`, `GET /Bundle/summary`
+
+### FR-402: Library API
+- **Direct Access**: All REST endpoints exposed as library methods
+- **80+ Methods**: Comprehensive programmatic interface including:
+ - `compileStructureMap(fmlContent)`
+ - `executeStructureMap(url, inputData)`
+ - `registerConceptMap(conceptMap)`
+ - `translateCode(system, code, targetSystem)`
+ - `registerValueSet(valueSet)`
+ - `validateCodeInValueSet(code, valueSetUrl)`
+ - `expandValueSet(valueSetUrl)`
+ - `registerCodeSystem(codeSystem)`
+ - `lookupConcept(system, code)`
+ - `testSubsumption(codeA, codeB, system)`
+ - `processBundle(bundle)`
+ - `getBundleStats()`
+- **No REST Dependency**: Library methods work independently of REST API
+
+### FR-403: OpenAPI Documentation
+- **Complete Specification**: All endpoints documented with OpenAPI 3.0
+- **JSON Schema**: Use JSON Schema for all non-FHIR standard endpoints
+- **Request/Response Examples**: Comprehensive examples for all operations
+- **Error Documentation**: Detailed error response specifications
+
+## Configuration and Deployment
+
+### FR-501: Server Configuration
+- **Port Configuration**: Command line parameter `--port/-p` and environment variable `PORT`
+- **Base URL Configuration**: Command line parameter `--base-url/-b` and environment variable `BASE_URL`
+- **Help Documentation**: `--help/-h` flag for usage information
+- **Default Values**: Sensible defaults (port 3000, base URL './test-data')
+
+### FR-502: External Dependencies
+- **FHIR Libraries**: Integration with mature FHIR Node.js packages:
+ - `fhirpath` v4.6.0 - Official HL7 FHIRPath library
+ - Additional FHIR utilities as needed
+- **No Partial Implementations**: Use official libraries instead of basic implementations
+- **Graceful Fallbacks**: Fail gracefully with "not implemented" rather than partial functionality
+
+## Validation and Quality
+
+### FR-601: Input Validation
+- **StructureDefinition Validation**: Validate input/output against logical models
+- **Execution Modes**:
+ - Strict mode: Fail on validation errors
+ - Non-strict mode: Issue warnings but continue
+- **FHIR Resource Validation**: Validate all FHIR resources against their profiles
+- **FML Syntax Validation**: Comprehensive FML syntax checking
+
+### FR-602: Error Handling
+- **Graceful Degradation**: Continue operation when possible
+- **Informative Errors**: Detailed error messages with context
+- **Logging**: Appropriate logging levels for debugging
+- **Error Recovery**: Attempt to extract useful information from invalid inputs
+
+### FR-603: Testing Requirements
+- **Comprehensive Coverage**: Tests covering all functional areas
+- **Matchbox Compatibility**: Replicate test patterns from Matchbox FhirMappingLanguageTests.java
+- **Performance Testing**: Tests for large Bundle processing and memory usage
+- **Integration Testing**: End-to-end workflow testing
+- **CI/CD Integration**: Automated testing on every commit/PR
+
+## Performance and Scalability
+
+### FR-701: Caching Strategy
+- **Simple Caching**: LRU-based internal caching without external management
+- **Memory Efficiency**: Automatic cache sizing based on available memory
+- **No External Cache APIs**: Internal optimization only, no external control
+
+### FR-702: Resource Optimization
+- **Memory Management**: Efficient memory usage for large Bundles
+- **Lazy Loading**: Load resources on-demand when possible
+- **Connection Pooling**: Efficient resource management for concurrent operations
+
+## Integration Requirements
+
+### FR-801: External System Integration
+- **SGEX Integration**: Copy logical model functionality from https://github.com/litlfred/sgex
+- **FHIR Server Compatibility**: Compatible with standard FHIR servers
+- **Bundle Import**: Support for importing resources from external FHIR Bundles
+- **Terminology Server Integration**: Support for external terminology services
+
+### FR-802: Library Usage
+- **Framework Integration**: Designed for integration into larger healthcare applications
+- **Microservice Architecture**: Support for microservice deployment patterns
+- **API Gateway Compatibility**: REST API compatible with API gateways
+- **Container Deployment**: Support for containerized deployment
+
+## Data Formats and Standards
+
+### FR-901: Supported Formats
+- **Input Formats**:
+ - FML source files (.map extension)
+ - FHIR StructureMap JSON
+ - FHIR Bundle JSON
+ - Individual FHIR resource JSON
+- **Output Formats**:
+ - FHIR StructureMap JSON
+ - Transformed resource JSON
+ - FHIR Bundle JSON
+ - Operation outcome JSON
+
+### FR-902: FHIR Compliance
+- **FHIR R4**: Full compliance with FHIR R4 specifications
+- **Resource Validation**: Validate against FHIR profiles
+- **Search Parameters**: Support standard FHIR search parameters
+- **Operation Framework**: Support FHIR operations framework
+- **Bundle Processing**: Support FHIR Bundle transaction semantics
+
+## Security and Access
+
+### FR-1001: Security Model
+- **Public Access**: All assets assumed to be public
+- **No Authentication**: No authentication mechanisms required
+- **Data Validation**: Validate all input data for safety
+- **Error Disclosure**: Careful error message disclosure to prevent information leakage
+
+## Documentation Requirements
+
+### FR-1101: User Documentation
+- **Installation Guide**: Comprehensive but concise installation instructions
+- **API Documentation**: Complete API reference with examples
+- **Tutorial Content**: Step-by-step guides for common use cases
+- **Configuration Guide**: Documentation for all configuration options
+
+### FR-1102: Developer Documentation
+- **Architecture Documentation**: System design and component interaction
+- **Extension Guide**: How to extend the library
+- **Testing Guide**: How to run and extend the test suite
+- **Contribution Guidelines**: How to contribute to the project
+
+## Compliance and Standards
+
+### FR-1201: Standards Compliance
+- **FHIR Mapping Language**: Full compliance with https://build.fhir.org/mapping-language.html
+- **FHIR Operations**: Compliance with FHIR operation specifications
+- **OpenAPI 3.0**: API specification compliance
+- **Node.js Best Practices**: Follow Node.js and TypeScript best practices
+
+### FR-1202: Quality Assurance
+- **Automated Testing**: Comprehensive test suite with CI/CD integration
+- **Code Quality**: Linting and code style enforcement
+- **Performance Testing**: Regular performance validation
+- **Documentation Testing**: Validate documentation examples
+
+---
+
+## Summary
+
+This FML Runner implementation provides a complete FHIR terminology ecosystem with robust FML processing capabilities, comprehensive REST API endpoints, and extensive library interfaces. All functionality is implemented with proper error handling, validation, and integration support while maintaining lean architecture principles and FHIR compliance.
+
+**Total Implementation**: 108 tests passing across all functional areas, providing confidence in the complete feature set.
\ No newline at end of file
diff --git a/docs/NPM_PUBLISHING.md b/docs/NPM_PUBLISHING.md
new file mode 100644
index 0000000..6663f18
--- /dev/null
+++ b/docs/NPM_PUBLISHING.md
@@ -0,0 +1,245 @@
+# NPM Publishing Guide
+
+This document describes the npm publishing process for the FML Runner monorepo packages.
+
+## Package Overview
+
+The FML Runner project consists of 4 npm packages published to the public npm registry:
+
+| Package | Description | NPM Link |
+|---------|-------------|----------|
+| **fmlrunner** | Core FML library with compilation and execution | [npm](https://www.npmjs.com/package/fmlrunner) |
+| **fmlrunner-rest** | REST API server with FHIR endpoints | [npm](https://www.npmjs.com/package/fmlrunner-rest) |
+| **fmlrunner-mcp** | Model Context Protocol interface for AI tools | [npm](https://www.npmjs.com/package/fmlrunner-mcp) |
+| **fmlrunner-web** | React web interface and documentation | [npm](https://www.npmjs.com/package/fmlrunner-web) |
+
+## Versioning Strategy
+
+All packages use **synchronized semantic versioning** (SEMVER):
+- **Patch** (0.1.1): Bug fixes, small improvements
+- **Minor** (0.2.0): New features, backward-compatible changes
+- **Major** (1.0.0): Breaking changes, major refactoring
+
+### Version Management
+
+Use the included versioning utility:
+
+```bash
+# Check current version
+npm run version:current
+
+# Bump version
+npm run version:patch # 0.1.0 โ 0.1.1
+npm run version:minor # 0.1.0 โ 0.2.0
+npm run version:major # 0.1.0 โ 1.0.0
+
+# Set specific version
+npm run version:set 1.2.3
+```
+
+## Publishing Methods
+
+### 1. Automated Publishing (Recommended)
+
+**Via GitHub Actions Workflow:**
+
+1. **Manual Trigger:**
+ - Go to Actions โ "Publish to NPM"
+ - Click "Run workflow"
+ - Select version type (patch/minor/major)
+ - Choose options:
+ - โ
Publish to NPM registry
+ - โ Dry run (for testing)
+
+2. **Release Trigger:**
+ - Create a new release on GitHub
+ - Tag format: `v1.2.3`
+ - Packages will be automatically published
+
+### 2. Manual Publishing
+
+**Prerequisites:**
+```bash
+# Set up npm authentication
+npm login
+# Enter your npm credentials
+
+# Or use npm token
+npm config set registry https://registry.npmjs.org/
+npm config set //registry.npmjs.org/:_authToken YOUR_NPM_TOKEN
+```
+
+**Publishing Steps:**
+```bash
+# 1. Quality checks
+npm run lint
+npm run test
+npm run build
+
+# 2. Dry run (test without publishing)
+npm run publish:dry-run
+
+# 3. Publish all packages
+npm run publish:all
+
+# 4. Create git tag
+npm run tag
+git push origin --tags
+```
+
+## Publishing Workflow Details
+
+### Dependency Order
+
+Packages are published in dependency order:
+
+1. **fmlrunner** (core library) - published first
+2. **fmlrunner-rest** (depends on fmlrunner)
+3. **fmlrunner-mcp** (depends on fmlrunner)
+4. **fmlrunner-web** (depends on fmlrunner)
+
+### Quality Gates
+
+Before publishing, the following checks are performed:
+
+- โ
**Linting** - ESLint validation
+- โ
**Testing** - All test suites pass
+- โ
**Building** - TypeScript compilation
+- โ
**Schema Validation** - JSON schemas compile
+- โ
**Package Verification** - Contents check
+
+### Post-Publishing
+
+After successful publishing:
+
+- ๐ท๏ธ **Git Tag** - Version tag created (`v1.2.3`)
+- ๐ **GitHub Release** - Release notes generated
+- ๐ **Summary Report** - Publishing results displayed
+
+## Environment Setup
+
+### GitHub Repository Secrets
+
+Configure these secrets in repository settings:
+
+```bash
+NPM_TOKEN=npm_your_publish_token_here
+```
+
+### NPM Token Setup
+
+1. **Generate NPM Token:**
+ ```bash
+ npm login
+ npm token create --read-only # For CI/CD
+ npm token create # For publishing
+ ```
+
+2. **Add to GitHub Secrets:**
+ - Go to repository Settings โ Secrets โ Actions
+ - Add `NPM_TOKEN` with your token value
+
+## Package Metadata
+
+Each package includes comprehensive metadata:
+
+### Core Features
+- **Keywords** - Relevant search terms
+- **Homepage** - GitHub repository link
+- **Repository** - Git repository URL
+- **Bug Reports** - Issues URL
+- **License** - MIT license
+- **Engine Requirements** - Node.js โฅ16, npm โฅ8
+
+### Publishing Configuration
+- **Public Access** - `access: public`
+- **Registry** - https://registry.npmjs.org/
+- **File Inclusion** - Only necessary files included
+- **Pre-publish Hooks** - Automated quality checks
+
+## Common Commands
+
+```bash
+# Development
+npm install # Install all dependencies
+npm run dev # Start development servers
+npm run build # Build all packages
+npm run test # Run all tests
+
+# Versioning
+npm run version:current # Show current version
+npm run version:patch # Bump patch version
+npm run version:minor # Bump minor version
+npm run version:major # Bump major version
+
+# Publishing
+npm run publish:dry-run # Test publishing (no actual publish)
+npm run publish:all # Publish all packages
+npm run release # Full release process
+
+# Utilities
+npm run clean # Clean build artifacts
+npm run lint # Run linting
+node scripts/version.js --help # Versioning utility help
+```
+
+## Troubleshooting
+
+### Common Issues
+
+**1. Authentication Errors**
+```bash
+npm whoami # Check if logged in
+npm login # Re-authenticate
+```
+
+**2. Version Conflicts**
+```bash
+npm run version:current # Check current version
+npm view fmlrunner versions # Check published versions
+```
+
+**3. Dependency Issues**
+```bash
+npm run clean # Clean build artifacts
+npm ci # Fresh dependency install
+npm run build # Rebuild packages
+```
+
+**4. Publishing Failures**
+```bash
+npm run publish:dry-run # Test publishing
+npm publish --access public --dry-run # Manual dry run
+```
+
+### Getting Help
+
+- ๐ **GitHub Issues** - [Report problems](https://github.com/litlfred/fmlrunner/issues)
+- ๐ **Documentation** - [Project README](../README.md)
+- ๐ง **Scripts** - `node scripts/version.js --help`
+
+## Release Checklist
+
+Before publishing a new version:
+
+- [ ] All tests passing locally
+- [ ] Documentation updated
+- [ ] CHANGELOG.md updated
+- [ ] Version bumped appropriately
+- [ ] Dependencies up to date
+- [ ] Security vulnerabilities addressed
+- [ ] Breaking changes documented
+- [ ] GitHub Actions workflow green
+- [ ] Dry run completed successfully
+
+After publishing:
+
+- [ ] Verify packages on npm registry
+- [ ] Test installation of published packages
+- [ ] Update project documentation
+- [ ] Announce release if significant
+- [ ] Monitor for issues/feedback
+
+---
+
+*This guide is part of the FML Runner project. For technical questions, please refer to the main documentation or open an issue.*
\ No newline at end of file
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 0000000..560033f
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,456 @@
+# FML Runner Node.js Library
+
+A comprehensive Node.js library for compiling and executing FHIR Mapping Language (FML) files to transform healthcare data using FHIR StructureMaps, with advanced validation capabilities and FHIR-compliant REST API.
+
+## Features
+
+### Core Functionality
+- **FML Compilation**: Transform FHIR Mapping Language content into valid FHIR StructureMap JSON resources
+- **StructureMap Execution**: Execute StructureMaps on input data with comprehensive error handling
+- **Multi-source Retrieval**: Load StructureMaps from local files or remote URLs with LRU-based caching
+- **FHIR Validation**: Validate input/output against StructureDefinitions with strict and non-strict modes
+
+### FHIR-Compliant REST API
+- **Complete CRUD Operations**: Full support for StructureMap and StructureDefinition resources
+- **$transform Operation**: Standard FHIR operation for content transformation
+- **Search Capabilities**: FHIR search parameters for resource discovery
+- **Validation Endpoints**: Direct validation of FHIR resources against profiles
+
+### Advanced Features
+- **Logical Model Support**: Work with custom logical models and profiles
+- **TypeScript Support**: Full type safety with comprehensive type definitions
+- **Caching System**: Performance optimization with LRU-based caching
+- **Production Ready**: Standalone server with health monitoring
+
+## Quick Start
+
+### Installation
+
+```bash
+npm install fml-runner
+```
+
+### Basic Usage
+
+```typescript
+import { FmlRunner } from 'fml-runner';
+
+// Initialize with options
+const fmlRunner = new FmlRunner({
+ baseUrl: './maps',
+ cacheEnabled: true,
+ strictMode: false
+});
+
+// Compile FML to StructureMap
+const fmlContent = `
+ map "http://example.org/StructureMap/Patient" = "PatientTransform"
+
+ group main(source src, target tgt) {
+ src.name -> tgt.fullName;
+ src.active -> tgt.isActive;
+ }
+`;
+
+const compilationResult = fmlRunner.compileFml(fmlContent);
+if (compilationResult.success) {
+ console.log('Compiled StructureMap:', compilationResult.structureMap);
+}
+
+// Execute StructureMap
+const inputData = {
+ name: 'John Doe',
+ active: true
+};
+
+const executionResult = await fmlRunner.executeStructureMap(
+ 'patient-transform.json',
+ inputData
+);
+
+if (executionResult.success) {
+ console.log('Transformed data:', executionResult.result);
+}
+```
+
+### Validation with Logical Models
+
+```typescript
+import { FmlRunner, ValidationService } from 'fml-runner';
+
+const fmlRunner = new FmlRunner({ strictMode: true });
+
+// Register a StructureDefinition for validation
+const patientProfile = {
+ resourceType: 'StructureDefinition',
+ url: 'http://example.org/StructureDefinition/Patient',
+ name: 'PatientProfile',
+ kind: 'resource',
+ type: 'Patient',
+ status: 'active',
+ snapshot: {
+ element: [
+ {
+ path: 'Patient',
+ min: 1,
+ max: '1'
+ },
+ {
+ path: 'Patient.name',
+ min: 1,
+ max: '*',
+ type: [{ code: 'string' }]
+ }
+ ]
+ }
+};
+
+fmlRunner.registerStructureDefinition(patientProfile);
+
+// Execute with validation
+const result = await fmlRunner.executeStructureMapWithValidation(
+ 'patient-transform.json',
+ inputData,
+ {
+ strictMode: true,
+ validateInput: true,
+ validateOutput: true,
+ inputProfile: 'http://example.org/StructureDefinition/Patient',
+ outputProfile: 'http://example.org/StructureDefinition/Patient'
+ }
+);
+
+console.log('Execution result:', result.result);
+console.log('Validation details:', result.validation);
+```
+
+## REST API
+
+### Starting the Server
+
+```bash
+# Using npm scripts
+npm start
+
+# Or with custom configuration
+PORT=3000 BASE_URL=./maps npm start
+```
+
+### Core Endpoints
+
+#### FML Compilation
+```http
+POST /api/v1/compile
+Content-Type: application/json
+
+{
+ "fmlContent": "map \"http://example.org/test\" = \"TestMap\" ..."
+}
+```
+
+#### StructureMap Execution
+```http
+POST /api/v1/execute
+Content-Type: application/json
+
+{
+ "structureMapReference": "transform.json",
+ "inputContent": { "name": "John Doe" }
+}
+```
+
+#### FHIR $transform Operation
+```http
+POST /api/v1/StructureMaps/$transform
+Content-Type: application/json
+
+{
+ "resourceType": "Parameters",
+ "parameter": [
+ {
+ "name": "source",
+ "resource": { "name": "John Doe" }
+ },
+ {
+ "name": "map",
+ "valueString": "patient-transform.json"
+ }
+ ]
+}
+```
+
+### FHIR-Compliant CRUD Operations
+
+#### StructureMaps
+- `GET /api/v1/StructureMaps` - Search StructureMaps
+- `GET /api/v1/StructureMaps/{id}` - Get StructureMap by ID
+- `POST /api/v1/StructureMaps` - Create new StructureMap
+- `PUT /api/v1/StructureMaps/{id}` - Update StructureMap
+- `DELETE /api/v1/StructureMaps/{id}` - Delete StructureMap
+
+#### StructureDefinitions
+- `GET /api/v1/StructureDefinitions` - Search StructureDefinitions
+- `POST /api/v1/StructureDefinitions` - Register logical model/profile
+- `PUT /api/v1/StructureDefinitions/{id}` - Update StructureDefinition
+- `DELETE /api/v1/StructureDefinitions/{id}` - Delete StructureDefinition
+
+#### Validation
+- `POST /api/v1/validate` - Validate resource against profile
+- `POST /api/v1/execute-with-validation` - Execute with validation
+
+### Search Parameters
+
+StructureMaps support standard FHIR search parameters:
+- `name` - Search by StructureMap name
+- `status` - Filter by status (draft, active, retired)
+- `url` - Search by canonical URL
+- `_count` - Limit number of results
+- `_offset` - Pagination offset
+
+Example:
+```http
+GET /api/v1/StructureMaps?name=patient&status=active&_count=10
+```
+
+## API Reference
+
+### Classes
+
+#### FmlRunner
+
+Main library class providing unified interface for all functionality.
+
+```typescript
+class FmlRunner {
+ constructor(options?: FmlRunnerOptions);
+
+ // Core methods
+ compileFml(fmlContent: string): FmlCompilationResult;
+ executeStructureMap(reference: string, input: any): Promise;
+ executeStructureMapWithValidation(reference: string, input: any, options?: ExecutionOptions): Promise;
+ getStructureMap(reference: string): Promise;
+
+ // Validation methods
+ registerStructureDefinition(structureDefinition: StructureDefinition): void;
+ getValidationService(): ValidationService | null;
+
+ // Cache management
+ clearCache(): void;
+ setBaseDirectory(directory: string): void;
+}
+```
+
+#### ValidationService
+
+Validation engine for FHIR resources against StructureDefinitions.
+
+```typescript
+class ValidationService {
+ registerStructureDefinition(structureDefinition: StructureDefinition): void;
+ validate(resource: any, profileUrl: string): ValidationResult;
+ clearStructureDefinitions(): void;
+ getStructureDefinitions(): StructureDefinition[];
+}
+```
+
+#### FmlRunnerApi
+
+Express.js server implementing the REST API.
+
+```typescript
+class FmlRunnerApi {
+ constructor(fmlRunner?: FmlRunner);
+ getApp(): express.Application;
+ listen(port?: number): void;
+}
+```
+
+### Types
+
+#### Configuration
+
+```typescript
+interface FmlRunnerOptions {
+ baseUrl?: string; // Base directory for StructureMap files
+ cacheEnabled?: boolean; // Enable LRU caching
+ timeout?: number; // Request timeout in milliseconds
+ strictMode?: boolean; // Enable strict validation mode
+}
+
+interface ExecutionOptions {
+ strictMode?: boolean; // Override global strict mode
+ validateInput?: boolean; // Validate input data
+ validateOutput?: boolean; // Validate output data
+ inputProfile?: string; // Input StructureDefinition URL
+ outputProfile?: string; // Output StructureDefinition URL
+}
+```
+
+#### Results
+
+```typescript
+interface FmlCompilationResult {
+ success: boolean;
+ structureMap?: StructureMap;
+ errors?: string[];
+}
+
+interface ExecutionResult {
+ success: boolean;
+ result?: any;
+ errors?: string[];
+}
+
+interface EnhancedExecutionResult extends ExecutionResult {
+ validation?: {
+ input?: ValidationResult;
+ output?: ValidationResult;
+ };
+}
+
+interface ValidationResult {
+ valid: boolean;
+ errors: ValidationError[];
+ warnings: ValidationWarning[];
+}
+```
+
+## Configuration
+
+### Environment Variables
+
+- `PORT` - Server port (default: 3000)
+- `BASE_URL` - Base directory for StructureMap files (default: ./maps)
+
+### FmlRunner Options
+
+```typescript
+const fmlRunner = new FmlRunner({
+ baseUrl: './structure-maps', // Directory containing StructureMap files
+ cacheEnabled: true, // Enable caching for performance
+ timeout: 10000, // Request timeout in milliseconds
+ strictMode: false // Global strict validation mode
+});
+```
+
+## Validation Modes
+
+### Strict Mode
+In strict mode, validation errors cause execution to fail:
+
+```typescript
+const result = await fmlRunner.executeStructureMapWithValidation(
+ 'transform.json',
+ inputData,
+ { strictMode: true, validateInput: true }
+);
+
+// Execution fails if input validation has errors
+if (!result.success) {
+ console.log('Validation failed:', result.errors);
+}
+```
+
+### Non-Strict Mode
+In non-strict mode, validation warnings are reported but execution continues:
+
+```typescript
+const result = await fmlRunner.executeStructureMapWithValidation(
+ 'transform.json',
+ inputData,
+ { strictMode: false, validateInput: true }
+);
+
+// Execution continues even with validation warnings
+console.log('Result:', result.result);
+console.log('Warnings:', result.validation?.input?.warnings);
+```
+
+## Error Handling
+
+The library uses FHIR-compliant error handling patterns:
+
+### OperationOutcome Format
+```typescript
+{
+ "resourceType": "OperationOutcome",
+ "issue": [
+ {
+ "severity": "error",
+ "code": "processing",
+ "diagnostics": "StructureMap execution failed: Invalid input data"
+ }
+ ]
+}
+```
+
+### Common Error Codes
+- `not-found` - Resource not found
+- `invalid` - Invalid request or resource
+- `processing` - Execution or transformation error
+- `exception` - Internal server error
+- `invariant` - Validation constraint violation
+
+## Performance Considerations
+
+### Caching
+- **LRU Cache**: Automatic caching of loaded StructureMaps
+- **Memory Management**: Configurable cache size based on available memory
+- **Cache Invalidation**: Manual cache clearing when needed
+
+### Optimization Tips
+- Enable caching for production environments
+- Use local file storage for frequently accessed StructureMaps
+- Register StructureDefinitions once during application startup
+- Consider request timeouts for external StructureMap URLs
+
+## Testing
+
+### Running Tests
+```bash
+# Run all tests
+npm test
+
+# Run specific test suite
+npm test tests/validation-service.test.ts
+
+# Run with coverage
+npm run test:coverage
+```
+
+### Test Structure
+- **Unit Tests**: Individual component testing
+- **Integration Tests**: API endpoint testing
+- **Validation Tests**: StructureDefinition and validation logic
+- **E2E Tests**: Complete workflow testing
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new functionality
+4. Ensure all tests pass
+5. Submit a pull request
+
+### Development Setup
+```bash
+git clone https://github.com/litlfred/fmlrunner.git
+cd fmlrunner
+npm install
+npm run build
+npm test
+```
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Changelog
+
+### v0.1.0
+- Initial release with core FML compilation and execution
+- FHIR-compliant REST API implementation
+- Advanced validation framework
+- StructureDefinition support for logical models
+- Comprehensive test coverage (61 tests)
+- Production-ready server with health monitoring
\ No newline at end of file
diff --git a/docs/REQUIREMENTS.md b/docs/REQUIREMENTS.md
new file mode 100644
index 0000000..ff85459
--- /dev/null
+++ b/docs/REQUIREMENTS.md
@@ -0,0 +1,70 @@
+# FML Runner Requirements
+
+## Overview
+
+The FML Runner is a Node.js library for compiling FHIR Mapping Language (FML) files and executing FHIR StructureMaps to transform healthcare data.
+
+## Core Functional Requirements
+
+### 1. FML Compilation (FR-001)
+**Requirement:** The library SHALL be able to take FHIR Mapping Language (FML) content and compile it to produce a FHIR StructureMap resource as JSON.
+
+**Acceptance Criteria:**
+- Accept FML content as input string
+- Parse and validate FML syntax
+- Generate valid FHIR StructureMap JSON resource
+- Handle compilation errors gracefully
+
+### 2. StructureMap Execution (FR-002)
+**Requirement:** The library SHALL be able to execute a StructureMap on given content multiple times efficiently.
+
+**Acceptance Criteria:**
+- Accept StructureMap reference and input content
+- Execute transformation according to StructureMap rules
+- Return transformed output
+- Support multiple executions of the same StructureMap
+- Cache compiled StructureMaps for performance
+
+### 3. StructureMap Retrieval (FR-003)
+**Requirement:** The library SHALL support retrieving StructureMaps from multiple sources.
+
+**Acceptance Criteria:**
+- Load StructureMaps from local directory relative to deployment
+- Load StructureMaps from URL using canonical identifier
+- Handle retrieval errors appropriately
+
+### 4. API Framework (FR-004)
+**Requirement:** The library SHALL provide a clean API framework that separates functionality appropriately.
+
+**Acceptance Criteria:**
+- Clear separation between compilation, execution, and retrieval
+- Well-defined interfaces for each function
+- Suitable for integration into larger application frameworks
+- Not a microservice itself, but suitable for use within microservices
+
+### 5. OpenAPI Specification (FR-005)
+**Requirement:** All API functionality SHALL be described using OpenAPI specification.
+
+**Acceptance Criteria:**
+- Complete OpenAPI 3.0 specification
+- Document all endpoints and operations
+- Include request/response schemas
+- Support for microservice architecture deployment
+
+## Technical Requirements
+
+### Library Architecture
+- **Target Platform:** Node.js >=16.0.0
+- **Package Type:** NPM package
+- **Usage Pattern:** Library for integration into larger applications
+- **API Style:** RESTful endpoints with OpenAPI specification
+
+### Error Handling
+- Graceful handling of compilation errors
+- Clear error messages for debugging
+- Proper HTTP status codes in API responses
+
+### Performance Considerations
+- Efficient caching of compiled StructureMaps
+- Optimize for multiple executions of the same StructureMap
+- Minimal memory footprint for library usage
\ No newline at end of file
diff --git a/docs/api.yaml b/docs/api.yaml
new file mode 100644
index 0000000..3d67616
--- /dev/null
+++ b/docs/api.yaml
@@ -0,0 +1,183 @@
+openapi: 3.0.3
+info:
+ title: FML Runner API
+ description: |
+ A comprehensive REST API for compiling and executing FHIR Mapping Language (FML) files
+ to transform healthcare data using FHIR StructureMaps, with advanced validation capabilities.
+
+ ## Features
+ - FML compilation to FHIR StructureMap resources
+ - StructureMap execution with validation support
+ - FHIR-compliant CRUD operations for StructureMaps and StructureDefinitions
+ - Standard FHIR $transform operation
+ - Resource validation against logical models and profiles
+ - Search capabilities with FHIR search parameters
+
+ version: 0.1.0
+ contact:
+ name: FML Runner Support
+ url: https://github.com/litlfred/fmlrunner
+ license:
+ name: MIT
+ url: https://opensource.org/licenses/MIT
+
+servers:
+ - url: http://localhost:3000/api/v1
+ description: Local development server
+ - url: https://api.example.org/fml/v1
+ description: Production server
+
+tags:
+ - name: FML Compilation
+ description: Compile FHIR Mapping Language to StructureMaps
+ - name: StructureMap Execution
+ description: Execute StructureMap transformations
+ - name: StructureMaps
+ description: FHIR-compliant StructureMap CRUD operations
+ - name: StructureDefinitions
+ description: Logical model and profile management
+ - name: Validation
+ description: Resource validation against profiles
+ - name: Health
+ description: System health and monitoring
+
+paths:
+ /compile:
+ post:
+ summary: Compile FML to StructureMap
+ description: Takes FHIR Mapping Language content and compiles it to a FHIR StructureMap JSON resource
+ operationId: compileFml
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ type: object
+ properties:
+ fmlContent:
+ type: string
+ description: The FML content to compile
+ required:
+ - fmlContent
+ responses:
+ '200':
+ description: Successfully compiled FML to StructureMap
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureMap'
+ '400':
+ description: Invalid FML content or compilation error
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Error'
+
+ /execute:
+ post:
+ summary: Execute StructureMap transformation
+ description: Execute a StructureMap on provided content
+ operationId: executeStructureMap
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ type: object
+ properties:
+ structureMapReference:
+ type: string
+ description: Reference to the StructureMap (URL or local path)
+ inputContent:
+ type: object
+ description: The content to transform
+ required:
+ - structureMapReference
+ - inputContent
+ responses:
+ '200':
+ description: Successfully executed transformation
+ content:
+ application/json:
+ schema:
+ type: object
+ properties:
+ result:
+ type: object
+ description: The transformed output
+ '400':
+ description: Invalid input or execution error
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Error'
+ '404':
+ description: StructureMap not found
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Error'
+
+ /structuremap/{reference}:
+ get:
+ summary: Retrieve StructureMap
+ description: Retrieve a StructureMap by reference (from directory or URL)
+ operationId: getStructureMap
+ parameters:
+ - name: reference
+ in: path
+ required: true
+ schema:
+ type: string
+ description: The StructureMap reference (filename or canonical URL)
+ responses:
+ '200':
+ description: Successfully retrieved StructureMap
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureMap'
+ '404':
+ description: StructureMap not found
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Error'
+
+components:
+ schemas:
+ StructureMap:
+ type: object
+ description: FHIR StructureMap resource
+ properties:
+ resourceType:
+ type: string
+ enum: [StructureMap]
+ id:
+ type: string
+ url:
+ type: string
+ name:
+ type: string
+ status:
+ type: string
+ enum: [draft, active, retired, unknown]
+ group:
+ type: array
+ items:
+ type: object
+ required:
+ - resourceType
+ - status
+
+ Error:
+ type: object
+ properties:
+ error:
+ type: string
+ description: Error message
+ details:
+ type: string
+ description: Additional error details
+ required:
+ - error
\ No newline at end of file
diff --git a/docs/openapi.yaml b/docs/openapi.yaml
new file mode 100644
index 0000000..65f0c64
--- /dev/null
+++ b/docs/openapi.yaml
@@ -0,0 +1,973 @@
+openapi: 3.0.3
+info:
+ title: FML Runner API
+ description: |
+ A comprehensive REST API for compiling and executing FHIR Mapping Language (FML) files
+ to transform healthcare data using FHIR StructureMaps, with advanced validation capabilities.
+
+ ## Features
+ - FML compilation to FHIR StructureMap resources
+ - StructureMap execution with validation support
+ - FHIR-compliant CRUD operations for StructureMaps and StructureDefinitions
+ - Standard FHIR $transform operation
+ - Resource validation against logical models and profiles
+ - Search capabilities with FHIR search parameters
+
+ version: 0.1.0
+ contact:
+ name: FML Runner Support
+ url: https://github.com/litlfred/fmlrunner
+ license:
+ name: MIT
+ url: https://opensource.org/licenses/MIT
+
+servers:
+ - url: http://localhost:3000/api/v1
+ description: Local development server
+ - url: https://api.example.org/fml/v1
+ description: Production server
+
+tags:
+ - name: FML Compilation
+ description: Compile FHIR Mapping Language to StructureMaps
+ - name: StructureMap Execution
+ description: Execute StructureMap transformations
+ - name: StructureMaps
+ description: FHIR-compliant StructureMap CRUD operations
+ - name: StructureDefinitions
+ description: Logical model and profile management
+ - name: Validation
+ description: Resource validation against profiles
+ - name: Health
+ description: System health and monitoring
+
+paths:
+ /compile:
+ post:
+ tags: [FML Compilation]
+ summary: Compile FML content to StructureMap
+ description: Transforms FHIR Mapping Language content into a valid FHIR StructureMap JSON resource
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ type: object
+ required: [fmlContent]
+ properties:
+ fmlContent:
+ type: string
+ description: FHIR Mapping Language content to compile
+ example: |
+ map "http://example.org/StructureMap/Patient" = "PatientTransform"
+
+ group main(source src, target tgt) {
+ src.name -> tgt.fullName;
+ src.active -> tgt.isActive;
+ }
+ responses:
+ '200':
+ description: Successfully compiled StructureMap
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureMap'
+ '400':
+ description: Compilation failed
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ErrorResponse'
+
+ /execute:
+ post:
+ tags: [StructureMap Execution]
+ summary: Execute StructureMap transformation
+ description: Executes a StructureMap on input content to produce transformed output
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ type: object
+ required: [structureMapReference, inputContent]
+ properties:
+ structureMapReference:
+ type: string
+ description: Reference to StructureMap (file path or URL)
+ example: "patient-transform.json"
+ inputContent:
+ type: object
+ description: Input data to transform
+ example:
+ name: "John Doe"
+ active: true
+ responses:
+ '200':
+ description: Successfully executed transformation
+ content:
+ application/json:
+ schema:
+ type: object
+ properties:
+ result:
+ type: object
+ description: Transformed output data
+ '400':
+ description: Execution failed
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ErrorResponse'
+
+ /execute-with-validation:
+ post:
+ tags: [StructureMap Execution, Validation]
+ summary: Execute StructureMap with validation
+ description: Executes a StructureMap with optional input/output validation against StructureDefinitions
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ type: object
+ required: [structureMapReference, inputContent]
+ properties:
+ structureMapReference:
+ type: string
+ description: Reference to StructureMap
+ inputContent:
+ type: object
+ description: Input data to transform
+ options:
+ $ref: '#/components/schemas/ExecutionOptions'
+ responses:
+ '200':
+ description: Successfully executed with validation details
+ content:
+ application/json:
+ schema:
+ type: object
+ properties:
+ result:
+ type: object
+ description: Transformed output data
+ validation:
+ $ref: '#/components/schemas/ValidationDetails'
+ '400':
+ description: Execution or validation failed
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ /validate:
+ post:
+ tags: [Validation]
+ summary: Validate resource against StructureDefinition
+ description: Validates a FHIR resource against a specified StructureDefinition profile
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ type: object
+ required: [resource, profile]
+ properties:
+ resource:
+ type: object
+ description: FHIR resource to validate
+ example:
+ resourceType: "Patient"
+ name: "John Doe"
+ profile:
+ type: string
+ description: StructureDefinition URL or name
+ example: "http://example.org/StructureDefinition/Patient"
+ responses:
+ '200':
+ description: Validation completed (may contain warnings)
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+ '400':
+ description: Validation failed with errors
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ /StructureMaps:
+ get:
+ tags: [StructureMaps]
+ summary: Search StructureMaps
+ description: Search for StructureMaps using FHIR search parameters
+ parameters:
+ - name: name
+ in: query
+ description: Search by StructureMap name
+ schema:
+ type: string
+ - name: status
+ in: query
+ description: Filter by status
+ schema:
+ type: string
+ enum: [draft, active, retired, unknown]
+ - name: url
+ in: query
+ description: Search by canonical URL
+ schema:
+ type: string
+ - name: _count
+ in: query
+ description: Number of results to return
+ schema:
+ type: integer
+ minimum: 1
+ maximum: 100
+ default: 20
+ - name: _offset
+ in: query
+ description: Starting position for pagination
+ schema:
+ type: integer
+ minimum: 0
+ default: 0
+ responses:
+ '200':
+ description: Search results
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Bundle'
+
+ post:
+ tags: [StructureMaps]
+ summary: Create new StructureMap
+ description: Creates a new StructureMap resource
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureMap'
+ responses:
+ '201':
+ description: StructureMap created successfully
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureMap'
+ '400':
+ description: Invalid StructureMap
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ /StructureMaps/{id}:
+ get:
+ tags: [StructureMaps]
+ summary: Get StructureMap by ID
+ description: Retrieves a specific StructureMap by its ID
+ parameters:
+ - name: id
+ in: path
+ required: true
+ description: StructureMap ID
+ schema:
+ type: string
+ responses:
+ '200':
+ description: StructureMap found
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureMap'
+ '404':
+ description: StructureMap not found
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ put:
+ tags: [StructureMaps]
+ summary: Update StructureMap
+ description: Updates an existing StructureMap or creates it if it doesn't exist
+ parameters:
+ - name: id
+ in: path
+ required: true
+ description: StructureMap ID
+ schema:
+ type: string
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureMap'
+ responses:
+ '200':
+ description: StructureMap updated successfully
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureMap'
+ '400':
+ description: Invalid StructureMap
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ delete:
+ tags: [StructureMaps]
+ summary: Delete StructureMap
+ description: Deletes a StructureMap by ID
+ parameters:
+ - name: id
+ in: path
+ required: true
+ description: StructureMap ID
+ schema:
+ type: string
+ responses:
+ '204':
+ description: StructureMap deleted successfully
+ '404':
+ description: StructureMap not found
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ /StructureMaps/$transform:
+ post:
+ tags: [StructureMaps]
+ summary: FHIR $transform operation
+ description: |
+ Standard FHIR operation for transforming content using a StructureMap.
+ Follows the specification at https://build.fhir.org/structuremap-operation-transform.html
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Parameters'
+ example:
+ resourceType: "Parameters"
+ parameter:
+ - name: "source"
+ resource:
+ name: "John Doe"
+ active: true
+ - name: "map"
+ valueString: "patient-transform.json"
+ responses:
+ '200':
+ description: Transformation completed successfully
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Parameters'
+ '400':
+ description: Transformation failed
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ /StructureDefinitions:
+ get:
+ tags: [StructureDefinitions]
+ summary: Search StructureDefinitions
+ description: Search for StructureDefinitions (logical models, profiles)
+ parameters:
+ - name: name
+ in: query
+ description: Search by name
+ schema:
+ type: string
+ - name: status
+ in: query
+ description: Filter by status
+ schema:
+ type: string
+ enum: [draft, active, retired, unknown]
+ - name: kind
+ in: query
+ description: Filter by kind
+ schema:
+ type: string
+ enum: [primitive-type, complex-type, resource, logical]
+ - name: type
+ in: query
+ description: Filter by type
+ schema:
+ type: string
+ - name: _count
+ in: query
+ description: Number of results to return
+ schema:
+ type: integer
+ minimum: 1
+ maximum: 100
+ default: 20
+ - name: _offset
+ in: query
+ description: Starting position for pagination
+ schema:
+ type: integer
+ minimum: 0
+ default: 0
+ responses:
+ '200':
+ description: Search results
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Bundle'
+
+ post:
+ tags: [StructureDefinitions]
+ summary: Create new StructureDefinition
+ description: Registers a new StructureDefinition for validation
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureDefinition'
+ responses:
+ '201':
+ description: StructureDefinition created successfully
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureDefinition'
+ '400':
+ description: Invalid StructureDefinition
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ /StructureDefinitions/{id}:
+ get:
+ tags: [StructureDefinitions]
+ summary: Get StructureDefinition by ID
+ description: Retrieves a specific StructureDefinition by its ID
+ parameters:
+ - name: id
+ in: path
+ required: true
+ description: StructureDefinition ID
+ schema:
+ type: string
+ responses:
+ '200':
+ description: StructureDefinition found
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureDefinition'
+ '404':
+ description: StructureDefinition not found
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ put:
+ tags: [StructureDefinitions]
+ summary: Update StructureDefinition
+ description: Updates an existing StructureDefinition
+ parameters:
+ - name: id
+ in: path
+ required: true
+ description: StructureDefinition ID
+ schema:
+ type: string
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureDefinition'
+ responses:
+ '200':
+ description: StructureDefinition updated successfully
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureDefinition'
+ '400':
+ description: Invalid StructureDefinition
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ delete:
+ tags: [StructureDefinitions]
+ summary: Delete StructureDefinition
+ description: Removes a StructureDefinition from the validation registry
+ parameters:
+ - name: id
+ in: path
+ required: true
+ description: StructureDefinition ID
+ schema:
+ type: string
+ responses:
+ '204':
+ description: StructureDefinition deleted successfully
+ '404':
+ description: StructureDefinition not found
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ /structuremap/{reference}:
+ get:
+ tags: [StructureMaps]
+ summary: Retrieve StructureMap by reference (legacy)
+ description: Legacy endpoint - retrieves a StructureMap by file path or URL reference
+ parameters:
+ - name: reference
+ in: path
+ required: true
+ description: StructureMap reference (file path or URL)
+ schema:
+ type: string
+ responses:
+ '200':
+ description: StructureMap found
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureMap'
+ '404':
+ description: StructureMap not found
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ErrorResponse'
+
+ /health:
+ get:
+ tags: [Health]
+ summary: Health check
+ description: Returns the health status of the service
+ responses:
+ '200':
+ description: Service is healthy
+ content:
+ application/json:
+ schema:
+ type: object
+ properties:
+ status:
+ type: string
+ example: "healthy"
+ timestamp:
+ type: string
+ format: date-time
+ example: "2024-01-15T10:30:00.000Z"
+ version:
+ type: string
+ example: "0.1.0"
+
+components:
+ schemas:
+ StructureMap:
+ type: object
+ required: [resourceType, status, group]
+ properties:
+ resourceType:
+ type: string
+ enum: [StructureMap]
+ id:
+ type: string
+ description: Logical ID of the resource
+ url:
+ type: string
+ description: Canonical URL for the StructureMap
+ name:
+ type: string
+ description: Name for the StructureMap
+ title:
+ type: string
+ description: Human-readable title
+ status:
+ type: string
+ enum: [draft, active, retired, unknown]
+ description: Publication status
+ experimental:
+ type: boolean
+ description: For testing purposes
+ description:
+ type: string
+ description: Natural language description
+ group:
+ type: array
+ description: Named groups within the StructureMap
+ items:
+ $ref: '#/components/schemas/StructureMapGroup'
+
+ StructureMapGroup:
+ type: object
+ required: [name, input, rule]
+ properties:
+ name:
+ type: string
+ description: Human-readable name for the group
+ typeMode:
+ type: string
+ enum: [none, types, type-and-types]
+ documentation:
+ type: string
+ description: Additional documentation
+ input:
+ type: array
+ description: Input variables for the group
+ items:
+ $ref: '#/components/schemas/StructureMapGroupInput'
+ rule:
+ type: array
+ description: Transformation rules
+ items:
+ $ref: '#/components/schemas/StructureMapGroupRule'
+
+ StructureMapGroupInput:
+ type: object
+ required: [name, mode]
+ properties:
+ name:
+ type: string
+ description: Name for the input
+ type:
+ type: string
+ description: Type for the input
+ mode:
+ type: string
+ enum: [source, target]
+ description: Input mode
+ documentation:
+ type: string
+ description: Documentation for the input
+
+ StructureMapGroupRule:
+ type: object
+ required: [source]
+ properties:
+ name:
+ type: string
+ description: Name of the rule
+ source:
+ type: array
+ description: Source inputs for the rule
+ items:
+ type: object
+ target:
+ type: array
+ description: Target outputs for the rule
+ items:
+ type: object
+ documentation:
+ type: string
+ description: Documentation for the rule
+
+ StructureDefinition:
+ type: object
+ required: [resourceType, status, kind, type]
+ properties:
+ resourceType:
+ type: string
+ enum: [StructureDefinition]
+ id:
+ type: string
+ description: Logical ID of the resource
+ url:
+ type: string
+ description: Canonical URL for the StructureDefinition
+ name:
+ type: string
+ description: Name for the StructureDefinition
+ title:
+ type: string
+ description: Human-readable title
+ status:
+ type: string
+ enum: [draft, active, retired, unknown]
+ description: Publication status
+ kind:
+ type: string
+ enum: [primitive-type, complex-type, resource, logical]
+ description: Kind of StructureDefinition
+ abstract:
+ type: boolean
+ description: Whether this is an abstract type
+ type:
+ type: string
+ description: Type being defined
+ baseDefinition:
+ type: string
+ description: Base StructureDefinition URL
+ derivation:
+ type: string
+ enum: [specialization, constraint]
+ description: How this relates to the base definition
+ snapshot:
+ $ref: '#/components/schemas/StructureDefinitionSnapshot'
+ differential:
+ $ref: '#/components/schemas/StructureDefinitionDifferential'
+
+ StructureDefinitionSnapshot:
+ type: object
+ required: [element]
+ properties:
+ element:
+ type: array
+ description: Element definitions in the snapshot
+ items:
+ $ref: '#/components/schemas/ElementDefinition'
+
+ StructureDefinitionDifferential:
+ type: object
+ required: [element]
+ properties:
+ element:
+ type: array
+ description: Element definitions in the differential
+ items:
+ $ref: '#/components/schemas/ElementDefinition'
+
+ ElementDefinition:
+ type: object
+ required: [path]
+ properties:
+ id:
+ type: string
+ description: Unique id for element in StructureDefinition
+ path:
+ type: string
+ description: Path of the element
+ sliceName:
+ type: string
+ description: Name of slice
+ min:
+ type: integer
+ minimum: 0
+ description: Minimum cardinality
+ max:
+ type: string
+ description: Maximum cardinality
+ type:
+ type: array
+ description: Data type and profile
+ items:
+ $ref: '#/components/schemas/ElementDefinitionType'
+ binding:
+ $ref: '#/components/schemas/ElementDefinitionBinding'
+
+ ElementDefinitionType:
+ type: object
+ required: [code]
+ properties:
+ code:
+ type: string
+ description: Data type or resource type
+ profile:
+ type: array
+ description: Profiles that apply to this type
+ items:
+ type: string
+
+ ElementDefinitionBinding:
+ type: object
+ properties:
+ strength:
+ type: string
+ enum: [required, extensible, preferred, example]
+ description: Binding strength
+ valueSet:
+ type: string
+ description: Source of value set
+
+ Parameters:
+ type: object
+ required: [resourceType]
+ properties:
+ resourceType:
+ type: string
+ enum: [Parameters]
+ id:
+ type: string
+ description: Logical ID of the resource
+ parameter:
+ type: array
+ description: Operation parameters
+ items:
+ $ref: '#/components/schemas/Parameter'
+
+ Parameter:
+ type: object
+ required: [name]
+ properties:
+ name:
+ type: string
+ description: Name of the parameter
+ valueString:
+ type: string
+ description: String value
+ valueUri:
+ type: string
+ description: URI value
+ resource:
+ type: object
+ description: Resource value
+
+ Bundle:
+ type: object
+ required: [resourceType, type]
+ properties:
+ resourceType:
+ type: string
+ enum: [Bundle]
+ id:
+ type: string
+ description: Logical ID of the resource
+ type:
+ type: string
+ enum: [searchset, collection, transaction, batch]
+ description: Bundle type
+ total:
+ type: integer
+ description: Total number of matching resources
+ entry:
+ type: array
+ description: Bundle entries
+ items:
+ type: object
+ properties:
+ resource:
+ type: object
+ description: Resource in the bundle
+
+ OperationOutcome:
+ type: object
+ required: [resourceType, issue]
+ properties:
+ resourceType:
+ type: string
+ enum: [OperationOutcome]
+ id:
+ type: string
+ description: Logical ID of the resource
+ issue:
+ type: array
+ description: Issues encountered
+ items:
+ $ref: '#/components/schemas/OperationOutcomeIssue'
+
+ OperationOutcomeIssue:
+ type: object
+ required: [severity, code]
+ properties:
+ severity:
+ type: string
+ enum: [fatal, error, warning, information]
+ description: Issue severity
+ code:
+ type: string
+ enum: [invalid, structure, required, value, invariant, security, login, unknown, expired, forbidden, suppressed, processing, not-supported, duplicate, multiple-matches, not-found, deleted, too-long, code-invalid, extension, too-costly, business-rule, conflict, transient, lock-error, no-store, exception, timeout, incomplete, throttled, informational]
+ description: Issue type
+ diagnostics:
+ type: string
+ description: Additional diagnostic information
+ location:
+ type: array
+ description: Path to element(s) with issue
+ items:
+ type: string
+
+ ExecutionOptions:
+ type: object
+ properties:
+ strictMode:
+ type: boolean
+ description: Enable strict validation mode
+ default: false
+ validateInput:
+ type: boolean
+ description: Validate input data
+ default: false
+ validateOutput:
+ type: boolean
+ description: Validate output data
+ default: false
+ inputProfile:
+ type: string
+ description: StructureDefinition URL for input validation
+ outputProfile:
+ type: string
+ description: StructureDefinition URL for output validation
+
+ ValidationDetails:
+ type: object
+ properties:
+ input:
+ $ref: '#/components/schemas/ValidationResult'
+ output:
+ $ref: '#/components/schemas/ValidationResult'
+
+ ValidationResult:
+ type: object
+ required: [valid, errors, warnings]
+ properties:
+ valid:
+ type: boolean
+ description: Whether validation passed
+ errors:
+ type: array
+ description: Validation errors
+ items:
+ $ref: '#/components/schemas/ValidationIssue'
+ warnings:
+ type: array
+ description: Validation warnings
+ items:
+ $ref: '#/components/schemas/ValidationIssue'
+
+ ValidationIssue:
+ type: object
+ required: [path, message, severity]
+ properties:
+ path:
+ type: string
+ description: FHIR path to the element with issue
+ message:
+ type: string
+ description: Description of the validation issue
+ severity:
+ type: string
+ enum: [error, warning]
+ description: Issue severity
+
+ ErrorResponse:
+ type: object
+ required: [error]
+ properties:
+ error:
+ type: string
+ description: Error message
+ details:
+ type: string
+ description: Additional error details
\ No newline at end of file
diff --git a/jest.config.js b/jest.config.js
new file mode 100644
index 0000000..0be3fa7
--- /dev/null
+++ b/jest.config.js
@@ -0,0 +1,10 @@
+module.exports = {
+ preset: 'ts-jest',
+ testEnvironment: 'node',
+ roots: ['/tests'],
+ testMatch: ['**/*.test.ts'],
+ collectCoverageFrom: [
+ 'src/**/*.ts',
+ '!src/**/*.d.ts',
+ ]
+};
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..f9cd3ec
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,7641 @@
+{
+ "name": "fmlrunner-monorepo",
+ "version": "0.1.0",
+ "lockfileVersion": 3,
+ "requires": true,
+ "packages": {
+ "": {
+ "name": "fmlrunner-monorepo",
+ "version": "0.1.0",
+ "license": "MIT",
+ "workspaces": [
+ "packages/fmlrunner",
+ "packages/fmlrunner-rest",
+ "packages/fmlrunner-mcp"
+ ],
+ "devDependencies": {
+ "@types/jest": "^29.0.0",
+ "@types/node": "^20.0.0",
+ "@typescript-eslint/eslint-plugin": "^6.0.0",
+ "@typescript-eslint/parser": "^6.0.0",
+ "concurrently": "^8.2.0",
+ "eslint": "^8.0.0",
+ "gh-pages": "^6.1.0",
+ "jest": "^29.0.0",
+ "ts-jest": "^29.0.0",
+ "typescript": "^5.0.0"
+ },
+ "engines": {
+ "node": ">=16.0.0",
+ "npm": ">=8.0.0"
+ }
+ },
+ "node_modules/@babel/code-frame": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
+ "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-validator-identifier": "^7.27.1",
+ "js-tokens": "^4.0.0",
+ "picocolors": "^1.1.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/compat-data": {
+ "version": "7.28.4",
+ "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.28.4.tgz",
+ "integrity": "sha512-YsmSKC29MJwf0gF8Rjjrg5LQCmyh+j/nD8/eP7f+BeoQTKYqs9RoWbjGOdy0+1Ekr68RJZMUOPVQaQisnIo4Rw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/core": {
+ "version": "7.28.4",
+ "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.4.tgz",
+ "integrity": "sha512-2BCOP7TN8M+gVDj7/ht3hsaO/B/n5oDbiAyyvnRlNOs+u1o+JWNYTQrmpuNp1/Wq2gcFrI01JAW+paEKDMx/CA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/code-frame": "^7.27.1",
+ "@babel/generator": "^7.28.3",
+ "@babel/helper-compilation-targets": "^7.27.2",
+ "@babel/helper-module-transforms": "^7.28.3",
+ "@babel/helpers": "^7.28.4",
+ "@babel/parser": "^7.28.4",
+ "@babel/template": "^7.27.2",
+ "@babel/traverse": "^7.28.4",
+ "@babel/types": "^7.28.4",
+ "@jridgewell/remapping": "^2.3.5",
+ "convert-source-map": "^2.0.0",
+ "debug": "^4.1.0",
+ "gensync": "^1.0.0-beta.2",
+ "json5": "^2.2.3",
+ "semver": "^6.3.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/babel"
+ }
+ },
+ "node_modules/@babel/core/node_modules/semver": {
+ "version": "6.3.1",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+ "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ }
+ },
+ "node_modules/@babel/generator": {
+ "version": "7.28.3",
+ "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.3.tgz",
+ "integrity": "sha512-3lSpxGgvnmZznmBkCRnVREPUFJv2wrv9iAoFDvADJc0ypmdOxdUtcLeBgBJ6zE0PMeTKnxeQzyk0xTBq4Ep7zw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/parser": "^7.28.3",
+ "@babel/types": "^7.28.2",
+ "@jridgewell/gen-mapping": "^0.3.12",
+ "@jridgewell/trace-mapping": "^0.3.28",
+ "jsesc": "^3.0.2"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-compilation-targets": {
+ "version": "7.27.2",
+ "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz",
+ "integrity": "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/compat-data": "^7.27.2",
+ "@babel/helper-validator-option": "^7.27.1",
+ "browserslist": "^4.24.0",
+ "lru-cache": "^5.1.1",
+ "semver": "^6.3.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-compilation-targets/node_modules/semver": {
+ "version": "6.3.1",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+ "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ }
+ },
+ "node_modules/@babel/helper-globals": {
+ "version": "7.28.0",
+ "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+ "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-module-imports": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz",
+ "integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/traverse": "^7.27.1",
+ "@babel/types": "^7.27.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-module-transforms": {
+ "version": "7.28.3",
+ "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.3.tgz",
+ "integrity": "sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-module-imports": "^7.27.1",
+ "@babel/helper-validator-identifier": "^7.27.1",
+ "@babel/traverse": "^7.28.3"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0"
+ }
+ },
+ "node_modules/@babel/helper-plugin-utils": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz",
+ "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-string-parser": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+ "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-validator-identifier": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
+ "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-validator-option": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+ "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helpers": {
+ "version": "7.28.4",
+ "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.4.tgz",
+ "integrity": "sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/template": "^7.27.2",
+ "@babel/types": "^7.28.4"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/parser": {
+ "version": "7.28.4",
+ "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.4.tgz",
+ "integrity": "sha512-yZbBqeM6TkpP9du/I2pUZnJsRMGGvOuIrhjzC1AwHwW+6he4mni6Bp/m8ijn0iOuZuPI2BfkCoSRunpyjnrQKg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/types": "^7.28.4"
+ },
+ "bin": {
+ "parser": "bin/babel-parser.js"
+ },
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-async-generators": {
+ "version": "7.8.4",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz",
+ "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.8.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-bigint": {
+ "version": "7.8.3",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz",
+ "integrity": "sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.8.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-class-properties": {
+ "version": "7.12.13",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz",
+ "integrity": "sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.12.13"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-class-static-block": {
+ "version": "7.14.5",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz",
+ "integrity": "sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.14.5"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-import-attributes": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.27.1.tgz",
+ "integrity": "sha512-oFT0FrKHgF53f4vOsZGi2Hh3I35PfSmVs4IBFLFj4dnafP+hIWDLg3VyKmUHfLoLHlyxY4C7DGtmHuJgn+IGww==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.27.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-import-meta": {
+ "version": "7.10.4",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz",
+ "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.10.4"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-json-strings": {
+ "version": "7.8.3",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz",
+ "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.8.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-jsx": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.27.1.tgz",
+ "integrity": "sha512-y8YTNIeKoyhGd9O0Jiyzyyqk8gdjnumGTQPsz0xOZOQ2RmkVJeZ1vmmfIvFEKqucBG6axJGBZDE/7iI5suUI/w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.27.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-logical-assignment-operators": {
+ "version": "7.10.4",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz",
+ "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.10.4"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-nullish-coalescing-operator": {
+ "version": "7.8.3",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz",
+ "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.8.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-numeric-separator": {
+ "version": "7.10.4",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz",
+ "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.10.4"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-object-rest-spread": {
+ "version": "7.8.3",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz",
+ "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.8.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-optional-catch-binding": {
+ "version": "7.8.3",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz",
+ "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.8.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-optional-chaining": {
+ "version": "7.8.3",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz",
+ "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.8.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-private-property-in-object": {
+ "version": "7.14.5",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz",
+ "integrity": "sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.14.5"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-top-level-await": {
+ "version": "7.14.5",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz",
+ "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.14.5"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-syntax-typescript": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.27.1.tgz",
+ "integrity": "sha512-xfYCBMxveHrRMnAWl1ZlPXOZjzkN82THFvLhQhFXFt81Z5HnN+EtUkZhv/zcKpmT3fzmWZB0ywiBrbC3vogbwQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.27.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/runtime": {
+ "version": "7.28.4",
+ "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.4.tgz",
+ "integrity": "sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/template": {
+ "version": "7.27.2",
+ "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz",
+ "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/code-frame": "^7.27.1",
+ "@babel/parser": "^7.27.2",
+ "@babel/types": "^7.27.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/traverse": {
+ "version": "7.28.4",
+ "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.4.tgz",
+ "integrity": "sha512-YEzuboP2qvQavAcjgQNVgsvHIDv6ZpwXvcvjmyySP2DIMuByS/6ioU5G9pYrWHM6T2YDfc7xga9iNzYOs12CFQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/code-frame": "^7.27.1",
+ "@babel/generator": "^7.28.3",
+ "@babel/helper-globals": "^7.28.0",
+ "@babel/parser": "^7.28.4",
+ "@babel/template": "^7.27.2",
+ "@babel/types": "^7.28.4",
+ "debug": "^4.3.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/types": {
+ "version": "7.28.4",
+ "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.4.tgz",
+ "integrity": "sha512-bkFqkLhh3pMBUQQkpVgWDWq/lqzc2678eUyDlTBhRqhCHFguYYGM0Efga7tYk4TogG/3x0EEl66/OQ+WGbWB/Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-string-parser": "^7.27.1",
+ "@babel/helper-validator-identifier": "^7.27.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@bcoe/v8-coverage": {
+ "version": "0.2.3",
+ "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz",
+ "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@colors/colors": {
+ "version": "1.6.0",
+ "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.6.0.tgz",
+ "integrity": "sha512-Ir+AOibqzrIsL6ajt3Rz3LskB7OiMVHqltZmspbW/TJuTVuyOMirVqAkjfY6JISiLHgyNqicAC8AyHHGzNd/dA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.1.90"
+ }
+ },
+ "node_modules/@dabh/diagnostics": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/@dabh/diagnostics/-/diagnostics-2.0.3.tgz",
+ "integrity": "sha512-hrlQOIi7hAfzsMqlGSFyVucrx38O+j6wiGOf//H2ecvIEqYN4ADBSS2iLMh5UFyDunCNniUIPk/q3riFv45xRA==",
+ "license": "MIT",
+ "dependencies": {
+ "colorspace": "1.1.x",
+ "enabled": "2.0.x",
+ "kuler": "^2.0.0"
+ }
+ },
+ "node_modules/@eslint-community/eslint-utils": {
+ "version": "4.8.0",
+ "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.8.0.tgz",
+ "integrity": "sha512-MJQFqrZgcW0UNYLGOuQpey/oTN59vyWwplvCGZztn1cKz9agZPPYpJB7h2OMmuu7VLqkvEjN8feFZJmxNF9D+Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "eslint-visitor-keys": "^3.4.3"
+ },
+ "engines": {
+ "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ },
+ "peerDependencies": {
+ "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+ }
+ },
+ "node_modules/@eslint-community/regexpp": {
+ "version": "4.12.1",
+ "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz",
+ "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+ }
+ },
+ "node_modules/@eslint/eslintrc": {
+ "version": "2.1.4",
+ "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz",
+ "integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ajv": "^6.12.4",
+ "debug": "^4.3.2",
+ "espree": "^9.6.0",
+ "globals": "^13.19.0",
+ "ignore": "^5.2.0",
+ "import-fresh": "^3.2.1",
+ "js-yaml": "^4.1.0",
+ "minimatch": "^3.1.2",
+ "strip-json-comments": "^3.1.1"
+ },
+ "engines": {
+ "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ }
+ },
+ "node_modules/@eslint/eslintrc/node_modules/brace-expansion": {
+ "version": "1.1.12",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+ "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0",
+ "concat-map": "0.0.1"
+ }
+ },
+ "node_modules/@eslint/eslintrc/node_modules/minimatch": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+ "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^1.1.7"
+ },
+ "engines": {
+ "node": "*"
+ }
+ },
+ "node_modules/@eslint/js": {
+ "version": "8.57.1",
+ "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.57.1.tgz",
+ "integrity": "sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+ }
+ },
+ "node_modules/@humanwhocodes/config-array": {
+ "version": "0.13.0",
+ "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.13.0.tgz",
+ "integrity": "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw==",
+ "deprecated": "Use @eslint/config-array instead",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@humanwhocodes/object-schema": "^2.0.3",
+ "debug": "^4.3.1",
+ "minimatch": "^3.0.5"
+ },
+ "engines": {
+ "node": ">=10.10.0"
+ }
+ },
+ "node_modules/@humanwhocodes/config-array/node_modules/brace-expansion": {
+ "version": "1.1.12",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+ "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0",
+ "concat-map": "0.0.1"
+ }
+ },
+ "node_modules/@humanwhocodes/config-array/node_modules/minimatch": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+ "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^1.1.7"
+ },
+ "engines": {
+ "node": "*"
+ }
+ },
+ "node_modules/@humanwhocodes/module-importer": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+ "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=12.22"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/nzakas"
+ }
+ },
+ "node_modules/@humanwhocodes/object-schema": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz",
+ "integrity": "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==",
+ "deprecated": "Use @eslint/object-schema instead",
+ "dev": true,
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/@istanbuljs/load-nyc-config": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz",
+ "integrity": "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "camelcase": "^5.3.1",
+ "find-up": "^4.1.0",
+ "get-package-type": "^0.1.0",
+ "js-yaml": "^3.13.1",
+ "resolve-from": "^5.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/@istanbuljs/load-nyc-config/node_modules/argparse": {
+ "version": "1.0.10",
+ "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+ "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "sprintf-js": "~1.0.2"
+ }
+ },
+ "node_modules/@istanbuljs/load-nyc-config/node_modules/find-up": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz",
+ "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "locate-path": "^5.0.0",
+ "path-exists": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/@istanbuljs/load-nyc-config/node_modules/js-yaml": {
+ "version": "3.14.1",
+ "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
+ "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "argparse": "^1.0.7",
+ "esprima": "^4.0.0"
+ },
+ "bin": {
+ "js-yaml": "bin/js-yaml.js"
+ }
+ },
+ "node_modules/@istanbuljs/load-nyc-config/node_modules/locate-path": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz",
+ "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "p-locate": "^4.1.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/@istanbuljs/load-nyc-config/node_modules/p-limit": {
+ "version": "2.3.0",
+ "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
+ "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "p-try": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/@istanbuljs/load-nyc-config/node_modules/p-locate": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz",
+ "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "p-limit": "^2.2.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/@istanbuljs/load-nyc-config/node_modules/resolve-from": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz",
+ "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/@istanbuljs/schema": {
+ "version": "0.1.3",
+ "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz",
+ "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/@jest/console": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/@jest/console/-/console-29.7.0.tgz",
+ "integrity": "sha512-5Ni4CU7XHQi32IJ398EEP4RrB8eV09sXP2ROqD4bksHrnTree52PsxvX8tpL8LvTZ3pFzXyPbNQReSN41CAhOg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/types": "^29.6.3",
+ "@types/node": "*",
+ "chalk": "^4.0.0",
+ "jest-message-util": "^29.7.0",
+ "jest-util": "^29.7.0",
+ "slash": "^3.0.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/@jest/core": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/@jest/core/-/core-29.7.0.tgz",
+ "integrity": "sha512-n7aeXWKMnGtDA48y8TLWJPJmLmmZ642Ceo78cYWEpiD7FzDgmNDV/GCVRorPABdXLJZ/9wzzgZAlHjXjxDHGsg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/console": "^29.7.0",
+ "@jest/reporters": "^29.7.0",
+ "@jest/test-result": "^29.7.0",
+ "@jest/transform": "^29.7.0",
+ "@jest/types": "^29.6.3",
+ "@types/node": "*",
+ "ansi-escapes": "^4.2.1",
+ "chalk": "^4.0.0",
+ "ci-info": "^3.2.0",
+ "exit": "^0.1.2",
+ "graceful-fs": "^4.2.9",
+ "jest-changed-files": "^29.7.0",
+ "jest-config": "^29.7.0",
+ "jest-haste-map": "^29.7.0",
+ "jest-message-util": "^29.7.0",
+ "jest-regex-util": "^29.6.3",
+ "jest-resolve": "^29.7.0",
+ "jest-resolve-dependencies": "^29.7.0",
+ "jest-runner": "^29.7.0",
+ "jest-runtime": "^29.7.0",
+ "jest-snapshot": "^29.7.0",
+ "jest-util": "^29.7.0",
+ "jest-validate": "^29.7.0",
+ "jest-watcher": "^29.7.0",
+ "micromatch": "^4.0.4",
+ "pretty-format": "^29.7.0",
+ "slash": "^3.0.0",
+ "strip-ansi": "^6.0.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ },
+ "peerDependencies": {
+ "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
+ },
+ "peerDependenciesMeta": {
+ "node-notifier": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@jest/environment": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-29.7.0.tgz",
+ "integrity": "sha512-aQIfHDq33ExsN4jP1NWGXhxgQ/wixs60gDiKO+XVMd8Mn0NWPWgc34ZQDTb2jKaUWQ7MuwoitXAsN2XVXNMpAw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/fake-timers": "^29.7.0",
+ "@jest/types": "^29.6.3",
+ "@types/node": "*",
+ "jest-mock": "^29.7.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/@jest/expect": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-29.7.0.tgz",
+ "integrity": "sha512-8uMeAMycttpva3P1lBHB8VciS9V0XAr3GymPpipdyQXbBcuhkLQOSe8E/p92RyAdToS6ZD1tFkX+CkhoECE0dQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "expect": "^29.7.0",
+ "jest-snapshot": "^29.7.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/@jest/expect-utils": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-29.7.0.tgz",
+ "integrity": "sha512-GlsNBWiFQFCVi9QVSx7f5AgMeLxe9YCCs5PuP2O2LdjDAA8Jh9eX7lA1Jq/xdXw3Wb3hyvlFNfZIfcRetSzYcA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "jest-get-type": "^29.6.3"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/@jest/fake-timers": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-29.7.0.tgz",
+ "integrity": "sha512-q4DH1Ha4TTFPdxLsqDXK1d3+ioSL7yL5oCMJZgDYm6i+6CygW5E5xVr/D1HdsGxjt1ZWSfUAs9OxSB/BNelWrQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/types": "^29.6.3",
+ "@sinonjs/fake-timers": "^10.0.2",
+ "@types/node": "*",
+ "jest-message-util": "^29.7.0",
+ "jest-mock": "^29.7.0",
+ "jest-util": "^29.7.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/@jest/globals": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-29.7.0.tgz",
+ "integrity": "sha512-mpiz3dutLbkW2MNFubUGUEVLkTGiqW6yLVTA+JbP6fI6J5iL9Y0Nlg8k95pcF8ctKwCS7WVxteBs29hhfAotzQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/environment": "^29.7.0",
+ "@jest/expect": "^29.7.0",
+ "@jest/types": "^29.6.3",
+ "jest-mock": "^29.7.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/@jest/reporters": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/@jest/reporters/-/reporters-29.7.0.tgz",
+ "integrity": "sha512-DApq0KJbJOEzAFYjHADNNxAE3KbhxQB1y5Kplb5Waqw6zVbuWatSnMjE5gs8FUgEPmNsnZA3NCWl9NG0ia04Pg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@bcoe/v8-coverage": "^0.2.3",
+ "@jest/console": "^29.7.0",
+ "@jest/test-result": "^29.7.0",
+ "@jest/transform": "^29.7.0",
+ "@jest/types": "^29.6.3",
+ "@jridgewell/trace-mapping": "^0.3.18",
+ "@types/node": "*",
+ "chalk": "^4.0.0",
+ "collect-v8-coverage": "^1.0.0",
+ "exit": "^0.1.2",
+ "glob": "^7.1.3",
+ "graceful-fs": "^4.2.9",
+ "istanbul-lib-coverage": "^3.0.0",
+ "istanbul-lib-instrument": "^6.0.0",
+ "istanbul-lib-report": "^3.0.0",
+ "istanbul-lib-source-maps": "^4.0.0",
+ "istanbul-reports": "^3.1.3",
+ "jest-message-util": "^29.7.0",
+ "jest-util": "^29.7.0",
+ "jest-worker": "^29.7.0",
+ "slash": "^3.0.0",
+ "string-length": "^4.0.1",
+ "strip-ansi": "^6.0.0",
+ "v8-to-istanbul": "^9.0.1"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ },
+ "peerDependencies": {
+ "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
+ },
+ "peerDependenciesMeta": {
+ "node-notifier": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@jest/schemas": {
+ "version": "29.6.3",
+ "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz",
+ "integrity": "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@sinclair/typebox": "^0.27.8"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/@jest/source-map": {
+ "version": "29.6.3",
+ "resolved": "https://registry.npmjs.org/@jest/source-map/-/source-map-29.6.3.tgz",
+ "integrity": "sha512-MHjT95QuipcPrpLM+8JMSzFx6eHp5Bm+4XeFDJlwsvVBjmKNiIAvasGK2fxz2WbGRlnvqehFbh07MMa7n3YJnw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/trace-mapping": "^0.3.18",
+ "callsites": "^3.0.0",
+ "graceful-fs": "^4.2.9"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/@jest/test-result": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-29.7.0.tgz",
+ "integrity": "sha512-Fdx+tv6x1zlkJPcWXmMDAG2HBnaR9XPSd5aDWQVsfrZmLVT3lU1cwyxLgRmXR9yrq4NBoEm9BMsfgFzTQAbJYA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/console": "^29.7.0",
+ "@jest/types": "^29.6.3",
+ "@types/istanbul-lib-coverage": "^2.0.0",
+ "collect-v8-coverage": "^1.0.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/@jest/test-sequencer": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-29.7.0.tgz",
+ "integrity": "sha512-GQwJ5WZVrKnOJuiYiAF52UNUJXgTZx1NHjFSEB0qEMmSZKAkdMoIzw/Cj6x6NF4AvV23AUqDpFzQkN/eYCYTxw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/test-result": "^29.7.0",
+ "graceful-fs": "^4.2.9",
+ "jest-haste-map": "^29.7.0",
+ "slash": "^3.0.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/@jest/transform": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-29.7.0.tgz",
+ "integrity": "sha512-ok/BTPFzFKVMwO5eOHRrvnBVHdRy9IrsrW1GpMaQ9MCnilNLXQKmAX8s1YXDFaai9xJpac2ySzV0YeRRECr2Vw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/core": "^7.11.6",
+ "@jest/types": "^29.6.3",
+ "@jridgewell/trace-mapping": "^0.3.18",
+ "babel-plugin-istanbul": "^6.1.1",
+ "chalk": "^4.0.0",
+ "convert-source-map": "^2.0.0",
+ "fast-json-stable-stringify": "^2.1.0",
+ "graceful-fs": "^4.2.9",
+ "jest-haste-map": "^29.7.0",
+ "jest-regex-util": "^29.6.3",
+ "jest-util": "^29.7.0",
+ "micromatch": "^4.0.4",
+ "pirates": "^4.0.4",
+ "slash": "^3.0.0",
+ "write-file-atomic": "^4.0.2"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/@jest/types": {
+ "version": "29.6.3",
+ "resolved": "https://registry.npmjs.org/@jest/types/-/types-29.6.3.tgz",
+ "integrity": "sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/schemas": "^29.6.3",
+ "@types/istanbul-lib-coverage": "^2.0.0",
+ "@types/istanbul-reports": "^3.0.0",
+ "@types/node": "*",
+ "@types/yargs": "^17.0.8",
+ "chalk": "^4.0.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/@jridgewell/gen-mapping": {
+ "version": "0.3.13",
+ "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+ "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/sourcemap-codec": "^1.5.0",
+ "@jridgewell/trace-mapping": "^0.3.24"
+ }
+ },
+ "node_modules/@jridgewell/remapping": {
+ "version": "2.3.5",
+ "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+ "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/gen-mapping": "^0.3.5",
+ "@jridgewell/trace-mapping": "^0.3.24"
+ }
+ },
+ "node_modules/@jridgewell/resolve-uri": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+ "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/@jridgewell/sourcemap-codec": {
+ "version": "1.5.5",
+ "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+ "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@jridgewell/trace-mapping": {
+ "version": "0.3.30",
+ "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.30.tgz",
+ "integrity": "sha512-GQ7Nw5G2lTu/BtHTKfXhKHok2WGetd4XYcVKGx00SjAk8GMwgJM3zr6zORiPGuOE+/vkc90KtTosSSvaCjKb2Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/resolve-uri": "^3.1.0",
+ "@jridgewell/sourcemap-codec": "^1.4.14"
+ }
+ },
+ "node_modules/@lhncbc/ucum-lhc": {
+ "version": "5.0.4",
+ "resolved": "https://registry.npmjs.org/@lhncbc/ucum-lhc/-/ucum-lhc-5.0.4.tgz",
+ "integrity": "sha512-khuV9GV51DF80b0wJmhZTR5Bf23fhS6SSIWnyGT9X+Uvn0FsHFl2LKViQ2TTOuvwagUOUSq8/0SyoE2ZDGwrAA==",
+ "license": "SEE LICENSE IN LICENSE.md",
+ "dependencies": {
+ "coffeescript": "^2.7.0",
+ "csv-parse": "^4.4.6",
+ "csv-stringify": "^1.0.4",
+ "escape-html": "^1.0.3",
+ "is-integer": "^1.0.6",
+ "jsonfile": "^2.2.3",
+ "stream": "0.0.2",
+ "stream-transform": "^0.1.1",
+ "string-to-stream": "^1.1.0",
+ "xmldoc": "^0.4.0"
+ }
+ },
+ "node_modules/@loxjs/url-join": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/@loxjs/url-join/-/url-join-1.0.2.tgz",
+ "integrity": "sha512-BqzK8+iHqxUbPRZV6NBum63CJzE0G6vGG3o+4dqeIzbywdoTg+xHJbksYDkk1P1w3Gj64U20Rgp44HHciLbRzg==",
+ "license": "MIT"
+ },
+ "node_modules/@modelcontextprotocol/sdk": {
+ "version": "0.5.0",
+ "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-0.5.0.tgz",
+ "integrity": "sha512-RXgulUX6ewvxjAG0kOpLMEdXXWkzWgaoCGaA2CwNW7cQCIphjpJhjpHSiaPdVCnisjRF/0Cm9KWHUuIoeiAblQ==",
+ "license": "MIT",
+ "dependencies": {
+ "content-type": "^1.0.5",
+ "raw-body": "^3.0.0",
+ "zod": "^3.23.8"
+ }
+ },
+ "node_modules/@modelcontextprotocol/sdk/node_modules/iconv-lite": {
+ "version": "0.7.0",
+ "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.0.tgz",
+ "integrity": "sha512-cf6L2Ds3h57VVmkZe+Pn+5APsT7FpqJtEhhieDCvrE2MK5Qk9MyffgQyuxQTm6BChfeZNtcOLHp9IcWRVcIcBQ==",
+ "license": "MIT",
+ "dependencies": {
+ "safer-buffer": ">= 2.1.2 < 3.0.0"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/express"
+ }
+ },
+ "node_modules/@modelcontextprotocol/sdk/node_modules/raw-body": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.1.tgz",
+ "integrity": "sha512-9G8cA+tuMS75+6G/TzW8OtLzmBDMo8p1JRxN5AZ+LAp8uxGA8V8GZm4GQ4/N5QNQEnLmg6SS7wyuSmbKepiKqA==",
+ "license": "MIT",
+ "dependencies": {
+ "bytes": "3.1.2",
+ "http-errors": "2.0.0",
+ "iconv-lite": "0.7.0",
+ "unpipe": "1.0.0"
+ },
+ "engines": {
+ "node": ">= 0.10"
+ }
+ },
+ "node_modules/@noble/hashes": {
+ "version": "1.8.0",
+ "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz",
+ "integrity": "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^14.21.3 || >=16"
+ },
+ "funding": {
+ "url": "https://paulmillr.com/funding/"
+ }
+ },
+ "node_modules/@nodelib/fs.scandir": {
+ "version": "2.1.5",
+ "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+ "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@nodelib/fs.stat": "2.0.5",
+ "run-parallel": "^1.1.9"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/@nodelib/fs.stat": {
+ "version": "2.0.5",
+ "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+ "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/@nodelib/fs.walk": {
+ "version": "1.2.8",
+ "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+ "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@nodelib/fs.scandir": "2.1.5",
+ "fastq": "^1.6.0"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/@paralleldrive/cuid2": {
+ "version": "2.2.2",
+ "resolved": "https://registry.npmjs.org/@paralleldrive/cuid2/-/cuid2-2.2.2.tgz",
+ "integrity": "sha512-ZOBkgDwEdoYVlSeRbYYXs0S9MejQofiVYoTbKzy/6GQa39/q5tQU2IX46+shYnUkpEl3wc+J6wRlar7r2EK2xA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@noble/hashes": "^1.1.5"
+ }
+ },
+ "node_modules/@scarf/scarf": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/@scarf/scarf/-/scarf-1.4.0.tgz",
+ "integrity": "sha512-xxeapPiUXdZAE3che6f3xogoJPeZgig6omHEy1rIY5WVsB3H2BHNnZH+gHG6x91SCWyQCzWGsuL2Hh3ClO5/qQ==",
+ "hasInstallScript": true,
+ "license": "Apache-2.0"
+ },
+ "node_modules/@sinclair/typebox": {
+ "version": "0.27.8",
+ "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz",
+ "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@sinonjs/commons": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-3.0.1.tgz",
+ "integrity": "sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "type-detect": "4.0.8"
+ }
+ },
+ "node_modules/@sinonjs/fake-timers": {
+ "version": "10.3.0",
+ "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-10.3.0.tgz",
+ "integrity": "sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "@sinonjs/commons": "^3.0.0"
+ }
+ },
+ "node_modules/@types/babel__core": {
+ "version": "7.20.5",
+ "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+ "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/parser": "^7.20.7",
+ "@babel/types": "^7.20.7",
+ "@types/babel__generator": "*",
+ "@types/babel__template": "*",
+ "@types/babel__traverse": "*"
+ }
+ },
+ "node_modules/@types/babel__generator": {
+ "version": "7.27.0",
+ "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+ "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/types": "^7.0.0"
+ }
+ },
+ "node_modules/@types/babel__template": {
+ "version": "7.4.4",
+ "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+ "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/parser": "^7.1.0",
+ "@babel/types": "^7.0.0"
+ }
+ },
+ "node_modules/@types/babel__traverse": {
+ "version": "7.28.0",
+ "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+ "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/types": "^7.28.2"
+ }
+ },
+ "node_modules/@types/body-parser": {
+ "version": "1.19.6",
+ "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.6.tgz",
+ "integrity": "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/connect": "*",
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@types/connect": {
+ "version": "3.4.38",
+ "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz",
+ "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@types/cookiejar": {
+ "version": "2.1.5",
+ "resolved": "https://registry.npmjs.org/@types/cookiejar/-/cookiejar-2.1.5.tgz",
+ "integrity": "sha512-he+DHOWReW0nghN24E1WUqM0efK4kI9oTqDm6XmK8ZPe2djZ90BSNdGnIyCLzCPw7/pogPlGbzI2wHGGmi4O/Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/cors": {
+ "version": "2.8.19",
+ "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz",
+ "integrity": "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@types/express": {
+ "version": "4.17.23",
+ "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.23.tgz",
+ "integrity": "sha512-Crp6WY9aTYP3qPi2wGDo9iUe/rceX01UMhnF1jmwDcKCFM6cx7YhGP/Mpr3y9AASpfHixIG0E6azCcL5OcDHsQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/body-parser": "*",
+ "@types/express-serve-static-core": "^4.17.33",
+ "@types/qs": "*",
+ "@types/serve-static": "*"
+ }
+ },
+ "node_modules/@types/express-serve-static-core": {
+ "version": "4.19.6",
+ "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.6.tgz",
+ "integrity": "sha512-N4LZ2xG7DatVqhCZzOGb1Yi5lMbXSZcmdLDe9EzSndPV2HpWYWzRbaerl2n27irrm94EPpprqa8KpskPT085+A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*",
+ "@types/qs": "*",
+ "@types/range-parser": "*",
+ "@types/send": "*"
+ }
+ },
+ "node_modules/@types/graceful-fs": {
+ "version": "4.1.9",
+ "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.9.tgz",
+ "integrity": "sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@types/http-errors": {
+ "version": "2.0.5",
+ "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.5.tgz",
+ "integrity": "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/istanbul-lib-coverage": {
+ "version": "2.0.6",
+ "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz",
+ "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/istanbul-lib-report": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz",
+ "integrity": "sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/istanbul-lib-coverage": "*"
+ }
+ },
+ "node_modules/@types/istanbul-reports": {
+ "version": "3.0.4",
+ "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz",
+ "integrity": "sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/istanbul-lib-report": "*"
+ }
+ },
+ "node_modules/@types/jest": {
+ "version": "29.5.14",
+ "resolved": "https://registry.npmjs.org/@types/jest/-/jest-29.5.14.tgz",
+ "integrity": "sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "expect": "^29.0.0",
+ "pretty-format": "^29.0.0"
+ }
+ },
+ "node_modules/@types/json-schema": {
+ "version": "7.0.15",
+ "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+ "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/methods": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/@types/methods/-/methods-1.1.4.tgz",
+ "integrity": "sha512-ymXWVrDiCxTBE3+RIrrP533E70eA+9qu7zdWoHuOmGujkYtzf4HQF96b8nwHLqhuf4ykX61IGRIB38CC6/sImQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/mime": {
+ "version": "1.3.5",
+ "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz",
+ "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/node": {
+ "version": "20.19.13",
+ "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.13.tgz",
+ "integrity": "sha512-yCAeZl7a0DxgNVteXFHt9+uyFbqXGy/ShC4BlcHkoE0AfGXYv/BUiplV72DjMYXHDBXFjhvr6DD1NiRVfB4j8g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "undici-types": "~6.21.0"
+ }
+ },
+ "node_modules/@types/qs": {
+ "version": "6.14.0",
+ "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.14.0.tgz",
+ "integrity": "sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/range-parser": {
+ "version": "1.2.7",
+ "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz",
+ "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/semver": {
+ "version": "7.7.1",
+ "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.7.1.tgz",
+ "integrity": "sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/send": {
+ "version": "0.17.5",
+ "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.5.tgz",
+ "integrity": "sha512-z6F2D3cOStZvuk2SaP6YrwkNO65iTZcwA2ZkSABegdkAh/lf+Aa/YQndZVfmEXT5vgAp6zv06VQ3ejSVjAny4w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/mime": "^1",
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@types/serve-static": {
+ "version": "1.15.8",
+ "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.8.tgz",
+ "integrity": "sha512-roei0UY3LhpOJvjbIP6ZZFngyLKl5dskOtDhxY5THRSpO+ZI+nzJ+m5yUMzGrp89YRa7lvknKkMYjqQFGwA7Sg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/http-errors": "*",
+ "@types/node": "*",
+ "@types/send": "*"
+ }
+ },
+ "node_modules/@types/stack-utils": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.3.tgz",
+ "integrity": "sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/superagent": {
+ "version": "8.1.9",
+ "resolved": "https://registry.npmjs.org/@types/superagent/-/superagent-8.1.9.tgz",
+ "integrity": "sha512-pTVjI73witn+9ILmoJdajHGW2jkSaOzhiFYF1Rd3EQ94kymLqB9PjD9ISg7WaALC7+dCHT0FGe9T2LktLq/3GQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/cookiejar": "^2.1.5",
+ "@types/methods": "^1.1.4",
+ "@types/node": "*",
+ "form-data": "^4.0.0"
+ }
+ },
+ "node_modules/@types/supertest": {
+ "version": "6.0.3",
+ "resolved": "https://registry.npmjs.org/@types/supertest/-/supertest-6.0.3.tgz",
+ "integrity": "sha512-8WzXq62EXFhJ7QsH3Ocb/iKQ/Ty9ZVWnVzoTKc9tyyFRRF3a74Tk2+TLFgaFFw364Ere+npzHKEJ6ga2LzIL7w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/methods": "^1.1.4",
+ "@types/superagent": "^8.1.0"
+ }
+ },
+ "node_modules/@types/swagger-ui-express": {
+ "version": "4.1.8",
+ "resolved": "https://registry.npmjs.org/@types/swagger-ui-express/-/swagger-ui-express-4.1.8.tgz",
+ "integrity": "sha512-AhZV8/EIreHFmBV5wAs0gzJUNq9JbbSXgJLQubCC0jtIo6prnI9MIRRxnU4MZX9RB9yXxF1V4R7jtLl/Wcj31g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/express": "*",
+ "@types/serve-static": "*"
+ }
+ },
+ "node_modules/@types/triple-beam": {
+ "version": "1.3.5",
+ "resolved": "https://registry.npmjs.org/@types/triple-beam/-/triple-beam-1.3.5.tgz",
+ "integrity": "sha512-6WaYesThRMCl19iryMYP7/x2OVgCtbIVflDGFpWnb9irXI3UjYE4AzmYuiUKY1AJstGijoY+MgUszMgRxIYTYw==",
+ "license": "MIT"
+ },
+ "node_modules/@types/yargs": {
+ "version": "17.0.33",
+ "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.33.tgz",
+ "integrity": "sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/yargs-parser": "*"
+ }
+ },
+ "node_modules/@types/yargs-parser": {
+ "version": "21.0.3",
+ "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.3.tgz",
+ "integrity": "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@typescript-eslint/eslint-plugin": {
+ "version": "6.21.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-6.21.0.tgz",
+ "integrity": "sha512-oy9+hTPCUFpngkEZUSzbf9MxI65wbKFoQYsgPdILTfbUldp5ovUuphZVe4i30emU9M/kP+T64Di0mxl7dSw3MA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@eslint-community/regexpp": "^4.5.1",
+ "@typescript-eslint/scope-manager": "6.21.0",
+ "@typescript-eslint/type-utils": "6.21.0",
+ "@typescript-eslint/utils": "6.21.0",
+ "@typescript-eslint/visitor-keys": "6.21.0",
+ "debug": "^4.3.4",
+ "graphemer": "^1.4.0",
+ "ignore": "^5.2.4",
+ "natural-compare": "^1.4.0",
+ "semver": "^7.5.4",
+ "ts-api-utils": "^1.0.1"
+ },
+ "engines": {
+ "node": "^16.0.0 || >=18.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ },
+ "peerDependencies": {
+ "@typescript-eslint/parser": "^6.0.0 || ^6.0.0-alpha",
+ "eslint": "^7.0.0 || ^8.0.0"
+ },
+ "peerDependenciesMeta": {
+ "typescript": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@typescript-eslint/parser": {
+ "version": "6.21.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-6.21.0.tgz",
+ "integrity": "sha512-tbsV1jPne5CkFQCgPBcDOt30ItF7aJoZL997JSF7MhGQqOeT3svWRYxiqlfA5RUdlHN6Fi+EI9bxqbdyAUZjYQ==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "@typescript-eslint/scope-manager": "6.21.0",
+ "@typescript-eslint/types": "6.21.0",
+ "@typescript-eslint/typescript-estree": "6.21.0",
+ "@typescript-eslint/visitor-keys": "6.21.0",
+ "debug": "^4.3.4"
+ },
+ "engines": {
+ "node": "^16.0.0 || >=18.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ },
+ "peerDependencies": {
+ "eslint": "^7.0.0 || ^8.0.0"
+ },
+ "peerDependenciesMeta": {
+ "typescript": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@typescript-eslint/scope-manager": {
+ "version": "6.21.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-6.21.0.tgz",
+ "integrity": "sha512-OwLUIWZJry80O99zvqXVEioyniJMa+d2GrqpUTqi5/v5D5rOrppJVBPa0yKCblcigC0/aYAzxxqQ1B+DS2RYsg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@typescript-eslint/types": "6.21.0",
+ "@typescript-eslint/visitor-keys": "6.21.0"
+ },
+ "engines": {
+ "node": "^16.0.0 || >=18.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ }
+ },
+ "node_modules/@typescript-eslint/type-utils": {
+ "version": "6.21.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-6.21.0.tgz",
+ "integrity": "sha512-rZQI7wHfao8qMX3Rd3xqeYSMCL3SoiSQLBATSiVKARdFGCYSRvmViieZjqc58jKgs8Y8i9YvVVhRbHSTA4VBag==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@typescript-eslint/typescript-estree": "6.21.0",
+ "@typescript-eslint/utils": "6.21.0",
+ "debug": "^4.3.4",
+ "ts-api-utils": "^1.0.1"
+ },
+ "engines": {
+ "node": "^16.0.0 || >=18.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ },
+ "peerDependencies": {
+ "eslint": "^7.0.0 || ^8.0.0"
+ },
+ "peerDependenciesMeta": {
+ "typescript": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@typescript-eslint/types": {
+ "version": "6.21.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-6.21.0.tgz",
+ "integrity": "sha512-1kFmZ1rOm5epu9NZEZm1kckCDGj5UJEf7P1kliH4LKu/RkwpsfqqGmY2OOcUs18lSlQBKLDYBOGxRVtrMN5lpg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^16.0.0 || >=18.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ }
+ },
+ "node_modules/@typescript-eslint/typescript-estree": {
+ "version": "6.21.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-6.21.0.tgz",
+ "integrity": "sha512-6npJTkZcO+y2/kr+z0hc4HwNfrrP4kNYh57ek7yCNlrBjWQ1Y0OS7jiZTkgumrvkX5HkEKXFZkkdFNkaW2wmUQ==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "@typescript-eslint/types": "6.21.0",
+ "@typescript-eslint/visitor-keys": "6.21.0",
+ "debug": "^4.3.4",
+ "globby": "^11.1.0",
+ "is-glob": "^4.0.3",
+ "minimatch": "9.0.3",
+ "semver": "^7.5.4",
+ "ts-api-utils": "^1.0.1"
+ },
+ "engines": {
+ "node": "^16.0.0 || >=18.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ },
+ "peerDependenciesMeta": {
+ "typescript": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@typescript-eslint/utils": {
+ "version": "6.21.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-6.21.0.tgz",
+ "integrity": "sha512-NfWVaC8HP9T8cbKQxHcsJBY5YE1O33+jpMwN45qzWWaPDZgLIbo12toGMWnmhvCpd3sIxkpDw3Wv1B3dYrbDQQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@eslint-community/eslint-utils": "^4.4.0",
+ "@types/json-schema": "^7.0.12",
+ "@types/semver": "^7.5.0",
+ "@typescript-eslint/scope-manager": "6.21.0",
+ "@typescript-eslint/types": "6.21.0",
+ "@typescript-eslint/typescript-estree": "6.21.0",
+ "semver": "^7.5.4"
+ },
+ "engines": {
+ "node": "^16.0.0 || >=18.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ },
+ "peerDependencies": {
+ "eslint": "^7.0.0 || ^8.0.0"
+ }
+ },
+ "node_modules/@typescript-eslint/visitor-keys": {
+ "version": "6.21.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-6.21.0.tgz",
+ "integrity": "sha512-JJtkDduxLi9bivAB+cYOVMtbkqdPOhZ+ZI5LC47MIRrDV4Yn2o+ZnW10Nkmr28xRpSpdJ6Sm42Hjf2+REYXm0A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@typescript-eslint/types": "6.21.0",
+ "eslint-visitor-keys": "^3.4.1"
+ },
+ "engines": {
+ "node": "^16.0.0 || >=18.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ }
+ },
+ "node_modules/@ungap/structured-clone": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
+ "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/accepts": {
+ "version": "1.3.8",
+ "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+ "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+ "license": "MIT",
+ "dependencies": {
+ "mime-types": "~2.1.34",
+ "negotiator": "0.6.3"
+ },
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/acorn": {
+ "version": "8.15.0",
+ "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
+ "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "acorn": "bin/acorn"
+ },
+ "engines": {
+ "node": ">=0.4.0"
+ }
+ },
+ "node_modules/acorn-jsx": {
+ "version": "5.3.2",
+ "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+ "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+ "dev": true,
+ "license": "MIT",
+ "peerDependencies": {
+ "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+ }
+ },
+ "node_modules/ajv": {
+ "version": "6.12.6",
+ "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+ "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fast-deep-equal": "^3.1.1",
+ "fast-json-stable-stringify": "^2.0.0",
+ "json-schema-traverse": "^0.4.1",
+ "uri-js": "^4.2.2"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/epoberezkin"
+ }
+ },
+ "node_modules/ajv-cli": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/ajv-cli/-/ajv-cli-5.0.0.tgz",
+ "integrity": "sha512-LY4m6dUv44HTyhV+u2z5uX4EhPYTM38Iv1jdgDJJJCyOOuqB8KtZEGjPZ2T+sh5ZIJrXUfgErYx/j3gLd3+PlQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ajv": "^8.0.0",
+ "fast-json-patch": "^2.0.0",
+ "glob": "^7.1.0",
+ "js-yaml": "^3.14.0",
+ "json-schema-migrate": "^2.0.0",
+ "json5": "^2.1.3",
+ "minimist": "^1.2.0"
+ },
+ "bin": {
+ "ajv": "dist/index.js"
+ },
+ "peerDependencies": {
+ "ts-node": ">=9.0.0"
+ },
+ "peerDependenciesMeta": {
+ "ts-node": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/ajv-cli/node_modules/ajv": {
+ "version": "8.17.1",
+ "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
+ "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fast-deep-equal": "^3.1.3",
+ "fast-uri": "^3.0.1",
+ "json-schema-traverse": "^1.0.0",
+ "require-from-string": "^2.0.2"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/epoberezkin"
+ }
+ },
+ "node_modules/ajv-cli/node_modules/argparse": {
+ "version": "1.0.10",
+ "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+ "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "sprintf-js": "~1.0.2"
+ }
+ },
+ "node_modules/ajv-cli/node_modules/js-yaml": {
+ "version": "3.14.1",
+ "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
+ "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "argparse": "^1.0.7",
+ "esprima": "^4.0.0"
+ },
+ "bin": {
+ "js-yaml": "bin/js-yaml.js"
+ }
+ },
+ "node_modules/ajv-cli/node_modules/json-schema-traverse": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+ "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/ajv-formats": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-2.1.1.tgz",
+ "integrity": "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==",
+ "license": "MIT",
+ "dependencies": {
+ "ajv": "^8.0.0"
+ },
+ "peerDependencies": {
+ "ajv": "^8.0.0"
+ },
+ "peerDependenciesMeta": {
+ "ajv": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/ajv-formats/node_modules/ajv": {
+ "version": "8.17.1",
+ "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
+ "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+ "license": "MIT",
+ "dependencies": {
+ "fast-deep-equal": "^3.1.3",
+ "fast-uri": "^3.0.1",
+ "json-schema-traverse": "^1.0.0",
+ "require-from-string": "^2.0.2"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/epoberezkin"
+ }
+ },
+ "node_modules/ajv-formats/node_modules/json-schema-traverse": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+ "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+ "license": "MIT"
+ },
+ "node_modules/ansi-escapes": {
+ "version": "4.3.2",
+ "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz",
+ "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "type-fest": "^0.21.3"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/ansi-escapes/node_modules/type-fest": {
+ "version": "0.21.3",
+ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz",
+ "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==",
+ "dev": true,
+ "license": "(MIT OR CC0-1.0)",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/ansi-regex": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+ "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/ansi-styles": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+ "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "color-convert": "^2.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+ }
+ },
+ "node_modules/antlr4": {
+ "version": "4.9.3",
+ "resolved": "https://registry.npmjs.org/antlr4/-/antlr4-4.9.3.tgz",
+ "integrity": "sha512-qNy2odgsa0skmNMCuxzXhM4M8J1YDaPv3TI+vCdnOAanu0N982wBrSqziDKRDctEZLZy9VffqIZXc0UGjjSP/g==",
+ "license": "BSD-3-Clause",
+ "engines": {
+ "node": ">=14"
+ }
+ },
+ "node_modules/anymatch": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+ "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "normalize-path": "^3.0.0",
+ "picomatch": "^2.0.4"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/argparse": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+ "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+ "dev": true,
+ "license": "Python-2.0"
+ },
+ "node_modules/array-flatten": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+ "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
+ "license": "MIT"
+ },
+ "node_modules/array-union": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz",
+ "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/asap": {
+ "version": "2.0.6",
+ "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz",
+ "integrity": "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/async": {
+ "version": "3.2.6",
+ "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
+ "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==",
+ "license": "MIT"
+ },
+ "node_modules/asynckit": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+ "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/babel-jest": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-29.7.0.tgz",
+ "integrity": "sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/transform": "^29.7.0",
+ "@types/babel__core": "^7.1.14",
+ "babel-plugin-istanbul": "^6.1.1",
+ "babel-preset-jest": "^29.6.3",
+ "chalk": "^4.0.0",
+ "graceful-fs": "^4.2.9",
+ "slash": "^3.0.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.8.0"
+ }
+ },
+ "node_modules/babel-plugin-istanbul": {
+ "version": "6.1.1",
+ "resolved": "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz",
+ "integrity": "sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.0.0",
+ "@istanbuljs/load-nyc-config": "^1.0.0",
+ "@istanbuljs/schema": "^0.1.2",
+ "istanbul-lib-instrument": "^5.0.4",
+ "test-exclude": "^6.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/babel-plugin-istanbul/node_modules/istanbul-lib-instrument": {
+ "version": "5.2.1",
+ "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.1.tgz",
+ "integrity": "sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "@babel/core": "^7.12.3",
+ "@babel/parser": "^7.14.7",
+ "@istanbuljs/schema": "^0.1.2",
+ "istanbul-lib-coverage": "^3.2.0",
+ "semver": "^6.3.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/babel-plugin-istanbul/node_modules/semver": {
+ "version": "6.3.1",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+ "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ }
+ },
+ "node_modules/babel-plugin-jest-hoist": {
+ "version": "29.6.3",
+ "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-29.6.3.tgz",
+ "integrity": "sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/template": "^7.3.3",
+ "@babel/types": "^7.3.3",
+ "@types/babel__core": "^7.1.14",
+ "@types/babel__traverse": "^7.0.6"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/babel-preset-current-node-syntax": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.2.0.tgz",
+ "integrity": "sha512-E/VlAEzRrsLEb2+dv8yp3bo4scof3l9nR4lrld+Iy5NyVqgVYUJnDAmunkhPMisRI32Qc4iRiz425d8vM++2fg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/plugin-syntax-async-generators": "^7.8.4",
+ "@babel/plugin-syntax-bigint": "^7.8.3",
+ "@babel/plugin-syntax-class-properties": "^7.12.13",
+ "@babel/plugin-syntax-class-static-block": "^7.14.5",
+ "@babel/plugin-syntax-import-attributes": "^7.24.7",
+ "@babel/plugin-syntax-import-meta": "^7.10.4",
+ "@babel/plugin-syntax-json-strings": "^7.8.3",
+ "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4",
+ "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3",
+ "@babel/plugin-syntax-numeric-separator": "^7.10.4",
+ "@babel/plugin-syntax-object-rest-spread": "^7.8.3",
+ "@babel/plugin-syntax-optional-catch-binding": "^7.8.3",
+ "@babel/plugin-syntax-optional-chaining": "^7.8.3",
+ "@babel/plugin-syntax-private-property-in-object": "^7.14.5",
+ "@babel/plugin-syntax-top-level-await": "^7.14.5"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0 || ^8.0.0-0"
+ }
+ },
+ "node_modules/babel-preset-jest": {
+ "version": "29.6.3",
+ "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-29.6.3.tgz",
+ "integrity": "sha512-0B3bhxR6snWXJZtR/RliHTDPRgn1sNHOR0yVtq/IiQFyuOVjFS+wuio/R4gSNkyYmKmJB4wGZv2NZanmKmTnNA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "babel-plugin-jest-hoist": "^29.6.3",
+ "babel-preset-current-node-syntax": "^1.0.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0"
+ }
+ },
+ "node_modules/balanced-match": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+ "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+ "license": "MIT"
+ },
+ "node_modules/body-parser": {
+ "version": "1.20.3",
+ "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz",
+ "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==",
+ "license": "MIT",
+ "dependencies": {
+ "bytes": "3.1.2",
+ "content-type": "~1.0.5",
+ "debug": "2.6.9",
+ "depd": "2.0.0",
+ "destroy": "1.2.0",
+ "http-errors": "2.0.0",
+ "iconv-lite": "0.4.24",
+ "on-finished": "2.4.1",
+ "qs": "6.13.0",
+ "raw-body": "2.5.2",
+ "type-is": "~1.6.18",
+ "unpipe": "1.0.0"
+ },
+ "engines": {
+ "node": ">= 0.8",
+ "npm": "1.2.8000 || >= 1.4.16"
+ }
+ },
+ "node_modules/body-parser/node_modules/debug": {
+ "version": "2.6.9",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+ "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+ "license": "MIT",
+ "dependencies": {
+ "ms": "2.0.0"
+ }
+ },
+ "node_modules/body-parser/node_modules/ms": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+ "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+ "license": "MIT"
+ },
+ "node_modules/brace-expansion": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+ "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0"
+ }
+ },
+ "node_modules/braces": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+ "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fill-range": "^7.1.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/browserslist": {
+ "version": "4.25.4",
+ "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.25.4.tgz",
+ "integrity": "sha512-4jYpcjabC606xJ3kw2QwGEZKX0Aw7sgQdZCvIK9dhVSPh76BKo+C+btT1RRofH7B+8iNpEbgGNVWiLki5q93yg==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/browserslist"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/funding/github/npm/browserslist"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "caniuse-lite": "^1.0.30001737",
+ "electron-to-chromium": "^1.5.211",
+ "node-releases": "^2.0.19",
+ "update-browserslist-db": "^1.1.3"
+ },
+ "bin": {
+ "browserslist": "cli.js"
+ },
+ "engines": {
+ "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+ }
+ },
+ "node_modules/bs-logger": {
+ "version": "0.2.6",
+ "resolved": "https://registry.npmjs.org/bs-logger/-/bs-logger-0.2.6.tgz",
+ "integrity": "sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fast-json-stable-stringify": "2.x"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/bser": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/bser/-/bser-2.1.1.tgz",
+ "integrity": "sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "node-int64": "^0.4.0"
+ }
+ },
+ "node_modules/buffer-from": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+ "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/bytes": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+ "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/call-bind-apply-helpers": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+ "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0",
+ "function-bind": "^1.1.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/call-bound": {
+ "version": "1.0.4",
+ "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+ "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+ "license": "MIT",
+ "dependencies": {
+ "call-bind-apply-helpers": "^1.0.2",
+ "get-intrinsic": "^1.3.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/callsites": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+ "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/camelcase": {
+ "version": "5.3.1",
+ "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
+ "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/caniuse-lite": {
+ "version": "1.0.30001741",
+ "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001741.tgz",
+ "integrity": "sha512-QGUGitqsc8ARjLdgAfxETDhRbJ0REsP6O3I96TAth/mVjh2cYzN2u+3AzPP3aVSm2FehEItaJw1xd+IGBXWeSw==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/browserslist"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "license": "CC-BY-4.0"
+ },
+ "node_modules/chalk": {
+ "version": "4.1.2",
+ "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+ "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-styles": "^4.1.0",
+ "supports-color": "^7.1.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/chalk?sponsor=1"
+ }
+ },
+ "node_modules/char-regex": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz",
+ "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/ci-info": {
+ "version": "3.9.0",
+ "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz",
+ "integrity": "sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/sibiraj-s"
+ }
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/cjs-module-lexer": {
+ "version": "1.4.3",
+ "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.4.3.tgz",
+ "integrity": "sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/cliui": {
+ "version": "8.0.1",
+ "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+ "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "string-width": "^4.2.0",
+ "strip-ansi": "^6.0.1",
+ "wrap-ansi": "^7.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/co": {
+ "version": "4.6.0",
+ "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz",
+ "integrity": "sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "iojs": ">= 1.0.0",
+ "node": ">= 0.12.0"
+ }
+ },
+ "node_modules/coffeescript": {
+ "version": "2.7.0",
+ "resolved": "https://registry.npmjs.org/coffeescript/-/coffeescript-2.7.0.tgz",
+ "integrity": "sha512-hzWp6TUE2d/jCcN67LrW1eh5b/rSDKQK6oD6VMLlggYVUUFexgTH9z3dNYihzX4RMhze5FTUsUmOXViJKFQR/A==",
+ "license": "MIT",
+ "bin": {
+ "cake": "bin/cake",
+ "coffee": "bin/coffee"
+ },
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/collect-v8-coverage": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/collect-v8-coverage/-/collect-v8-coverage-1.0.2.tgz",
+ "integrity": "sha512-lHl4d5/ONEbLlJvaJNtsF/Lz+WvB07u2ycqTYbdrq7UypDXailES4valYb2eWiJFxZlVmpGekfqoxQhzyFdT4Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/color": {
+ "version": "3.2.1",
+ "resolved": "https://registry.npmjs.org/color/-/color-3.2.1.tgz",
+ "integrity": "sha512-aBl7dZI9ENN6fUGC7mWpMTPNHmWUSNan9tuWN6ahh5ZLNk9baLJOnSMlrQkHcrfFgz2/RigjUVAjdx36VcemKA==",
+ "license": "MIT",
+ "dependencies": {
+ "color-convert": "^1.9.3",
+ "color-string": "^1.6.0"
+ }
+ },
+ "node_modules/color-convert": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+ "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "color-name": "~1.1.4"
+ },
+ "engines": {
+ "node": ">=7.0.0"
+ }
+ },
+ "node_modules/color-name": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+ "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+ "license": "MIT"
+ },
+ "node_modules/color-string": {
+ "version": "1.9.1",
+ "resolved": "https://registry.npmjs.org/color-string/-/color-string-1.9.1.tgz",
+ "integrity": "sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==",
+ "license": "MIT",
+ "dependencies": {
+ "color-name": "^1.0.0",
+ "simple-swizzle": "^0.2.2"
+ }
+ },
+ "node_modules/color/node_modules/color-convert": {
+ "version": "1.9.3",
+ "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+ "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+ "license": "MIT",
+ "dependencies": {
+ "color-name": "1.1.3"
+ }
+ },
+ "node_modules/color/node_modules/color-name": {
+ "version": "1.1.3",
+ "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+ "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
+ "license": "MIT"
+ },
+ "node_modules/colorspace": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/colorspace/-/colorspace-1.1.4.tgz",
+ "integrity": "sha512-BgvKJiuVu1igBUF2kEjRCZXol6wiiGbY5ipL/oVPwm0BL9sIpMIzM8IK7vwuxIIzOXMV3Ey5w+vxhm0rR/TN8w==",
+ "license": "MIT",
+ "dependencies": {
+ "color": "^3.1.3",
+ "text-hex": "1.0.x"
+ }
+ },
+ "node_modules/combined-stream": {
+ "version": "1.0.8",
+ "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+ "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "delayed-stream": "~1.0.0"
+ },
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/commander": {
+ "version": "2.20.3",
+ "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
+ "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
+ "license": "MIT"
+ },
+ "node_modules/commondir": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz",
+ "integrity": "sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/component-emitter": {
+ "version": "1.3.1",
+ "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.1.tgz",
+ "integrity": "sha512-T0+barUSQRTUQASh8bx02dl+DhF54GtIDY13Y3m9oWTklKbb3Wv974meRpeZ3lp1JpLVECWWNHC4vaG2XHXouQ==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/concat-map": {
+ "version": "0.0.1",
+ "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+ "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+ "license": "MIT"
+ },
+ "node_modules/concurrently": {
+ "version": "8.2.2",
+ "resolved": "https://registry.npmjs.org/concurrently/-/concurrently-8.2.2.tgz",
+ "integrity": "sha512-1dP4gpXFhei8IOtlXRE/T/4H88ElHgTiUzh71YUmtjTEHMSRS2Z/fgOxHSxxusGHogsRfxNq1vyAwxSC+EVyDg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "chalk": "^4.1.2",
+ "date-fns": "^2.30.0",
+ "lodash": "^4.17.21",
+ "rxjs": "^7.8.1",
+ "shell-quote": "^1.8.1",
+ "spawn-command": "0.0.2",
+ "supports-color": "^8.1.1",
+ "tree-kill": "^1.2.2",
+ "yargs": "^17.7.2"
+ },
+ "bin": {
+ "conc": "dist/bin/concurrently.js",
+ "concurrently": "dist/bin/concurrently.js"
+ },
+ "engines": {
+ "node": "^14.13.0 || >=16.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/open-cli-tools/concurrently?sponsor=1"
+ }
+ },
+ "node_modules/concurrently/node_modules/date-fns": {
+ "version": "2.30.0",
+ "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-2.30.0.tgz",
+ "integrity": "sha512-fnULvOpxnC5/Vg3NCiWelDsLiUc9bRwAPs/+LfTLNvetFCtCTN+yQz15C/fs4AwX1R9K5GLtLfn8QW+dWisaAw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.21.0"
+ },
+ "engines": {
+ "node": ">=0.11"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/date-fns"
+ }
+ },
+ "node_modules/concurrently/node_modules/supports-color": {
+ "version": "8.1.1",
+ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
+ "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "has-flag": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/supports-color?sponsor=1"
+ }
+ },
+ "node_modules/content-disposition": {
+ "version": "0.5.4",
+ "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+ "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+ "license": "MIT",
+ "dependencies": {
+ "safe-buffer": "5.2.1"
+ },
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/content-type": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+ "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/convert-source-map": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+ "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/cookie": {
+ "version": "0.7.1",
+ "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz",
+ "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/cookie-signature": {
+ "version": "1.0.6",
+ "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+ "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==",
+ "license": "MIT"
+ },
+ "node_modules/cookiejar": {
+ "version": "2.1.4",
+ "resolved": "https://registry.npmjs.org/cookiejar/-/cookiejar-2.1.4.tgz",
+ "integrity": "sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/core-util-is": {
+ "version": "1.0.3",
+ "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
+ "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
+ "license": "MIT"
+ },
+ "node_modules/cors": {
+ "version": "2.8.5",
+ "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
+ "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+ "license": "MIT",
+ "dependencies": {
+ "object-assign": "^4",
+ "vary": "^1"
+ },
+ "engines": {
+ "node": ">= 0.10"
+ }
+ },
+ "node_modules/create-jest": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/create-jest/-/create-jest-29.7.0.tgz",
+ "integrity": "sha512-Adz2bdH0Vq3F53KEMJOoftQFutWCukm6J24wbPWRO4k1kMY7gS7ds/uoJkNuV8wDCtWWnuwGcJwpWcih+zEW1Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/types": "^29.6.3",
+ "chalk": "^4.0.0",
+ "exit": "^0.1.2",
+ "graceful-fs": "^4.2.9",
+ "jest-config": "^29.7.0",
+ "jest-util": "^29.7.0",
+ "prompts": "^2.0.1"
+ },
+ "bin": {
+ "create-jest": "bin/create-jest.js"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/cross-spawn": {
+ "version": "7.0.6",
+ "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+ "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "path-key": "^3.1.0",
+ "shebang-command": "^2.0.0",
+ "which": "^2.0.1"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/csv-parse": {
+ "version": "4.16.3",
+ "resolved": "https://registry.npmjs.org/csv-parse/-/csv-parse-4.16.3.tgz",
+ "integrity": "sha512-cO1I/zmz4w2dcKHVvpCr7JVRu8/FymG5OEpmvsZYlccYolPBLoVGKUHgNoc4ZGkFeFlWGEDmMyBM+TTqRdW/wg==",
+ "license": "MIT"
+ },
+ "node_modules/csv-stringify": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/csv-stringify/-/csv-stringify-1.1.2.tgz",
+ "integrity": "sha512-3NmNhhd+AkYs5YtM1GEh01VR6PKj6qch2ayfQaltx5xpcAdThjnbbI5eT8CzRVpXfGKAxnmrSYLsNl/4f3eWiw==",
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "lodash.get": "~4.4.2"
+ }
+ },
+ "node_modules/date-fns": {
+ "version": "1.30.1",
+ "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-1.30.1.tgz",
+ "integrity": "sha512-hBSVCvSmWC+QypYObzwGOd9wqdDpOt+0wl0KbU+R+uuZBS1jN8VsD1ss3irQDknRj5NvxiTF6oj/nDRnN/UQNw==",
+ "license": "MIT"
+ },
+ "node_modules/debug": {
+ "version": "4.4.1",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+ "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ms": "^2.1.3"
+ },
+ "engines": {
+ "node": ">=6.0"
+ },
+ "peerDependenciesMeta": {
+ "supports-color": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/dedent": {
+ "version": "1.7.0",
+ "resolved": "https://registry.npmjs.org/dedent/-/dedent-1.7.0.tgz",
+ "integrity": "sha512-HGFtf8yhuhGhqO07SV79tRp+br4MnbdjeVxotpn1QBl30pcLLCQjX5b2295ll0fv8RKDKsmWYrl05usHM9CewQ==",
+ "dev": true,
+ "license": "MIT",
+ "peerDependencies": {
+ "babel-plugin-macros": "^3.1.0"
+ },
+ "peerDependenciesMeta": {
+ "babel-plugin-macros": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/deep-is": {
+ "version": "0.1.4",
+ "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+ "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/deepmerge": {
+ "version": "4.3.1",
+ "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",
+ "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/delayed-stream": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+ "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.4.0"
+ }
+ },
+ "node_modules/depd": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+ "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/destroy": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+ "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.8",
+ "npm": "1.2.8000 || >= 1.4.16"
+ }
+ },
+ "node_modules/detect-newline": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz",
+ "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/dezalgo": {
+ "version": "1.0.4",
+ "resolved": "https://registry.npmjs.org/dezalgo/-/dezalgo-1.0.4.tgz",
+ "integrity": "sha512-rXSP0bf+5n0Qonsb+SVVfNfIsimO4HEtmnIpPHY8Q1UCzKlQrDMfdobr8nJOOsRgWCyMRqeSBQzmWUMq7zvVig==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "asap": "^2.0.0",
+ "wrappy": "1"
+ }
+ },
+ "node_modules/diff-sequences": {
+ "version": "29.6.3",
+ "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.6.3.tgz",
+ "integrity": "sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/dir-glob": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz",
+ "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "path-type": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/doctrine": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
+ "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "esutils": "^2.0.2"
+ },
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/dunder-proto": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+ "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+ "license": "MIT",
+ "dependencies": {
+ "call-bind-apply-helpers": "^1.0.1",
+ "es-errors": "^1.3.0",
+ "gopd": "^1.2.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/ee-first": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+ "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+ "license": "MIT"
+ },
+ "node_modules/electron-to-chromium": {
+ "version": "1.5.214",
+ "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.214.tgz",
+ "integrity": "sha512-TpvUNdha+X3ybfU78NoQatKvQEm1oq3lf2QbnmCEdw+Bd9RuIAY+hJTvq1avzHM0f7EJfnH3vbCnbzKzisc/9Q==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/email-addresses": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/email-addresses/-/email-addresses-5.0.0.tgz",
+ "integrity": "sha512-4OIPYlA6JXqtVn8zpHpGiI7vE6EQOAg16aGnDMIAlZVinnoZ8208tW1hAbjWydgN/4PLTT9q+O1K6AH/vALJGw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/emitter-component": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/emitter-component/-/emitter-component-1.1.2.tgz",
+ "integrity": "sha512-QdXO3nXOzZB4pAjM0n6ZE+R9/+kPpECA/XSELIcc54NeYVnBqIk+4DFiBgK+8QbV3mdvTG6nedl7dTYgO+5wDw==",
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/emittery": {
+ "version": "0.13.1",
+ "resolved": "https://registry.npmjs.org/emittery/-/emittery-0.13.1.tgz",
+ "integrity": "sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://github.com/sindresorhus/emittery?sponsor=1"
+ }
+ },
+ "node_modules/emoji-regex": {
+ "version": "8.0.0",
+ "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+ "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/enabled": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/enabled/-/enabled-2.0.0.tgz",
+ "integrity": "sha512-AKrN98kuwOzMIdAizXGI86UFBoo26CL21UM763y1h/GMSJ4/OHU9k2YlsmBpyScFo/wbLzWQJBMCW4+IO3/+OQ==",
+ "license": "MIT"
+ },
+ "node_modules/encodeurl": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+ "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/error-ex": {
+ "version": "1.3.2",
+ "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz",
+ "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "is-arrayish": "^0.2.1"
+ }
+ },
+ "node_modules/es-define-property": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+ "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es-errors": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+ "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es-object-atoms": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+ "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es-set-tostringtag": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+ "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0",
+ "get-intrinsic": "^1.2.6",
+ "has-tostringtag": "^1.0.2",
+ "hasown": "^2.0.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/escalade": {
+ "version": "3.2.0",
+ "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+ "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/escape-html": {
+ "version": "1.0.3",
+ "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+ "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+ "license": "MIT"
+ },
+ "node_modules/escape-string-regexp": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+ "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/eslint": {
+ "version": "8.57.1",
+ "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.1.tgz",
+ "integrity": "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==",
+ "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@eslint-community/eslint-utils": "^4.2.0",
+ "@eslint-community/regexpp": "^4.6.1",
+ "@eslint/eslintrc": "^2.1.4",
+ "@eslint/js": "8.57.1",
+ "@humanwhocodes/config-array": "^0.13.0",
+ "@humanwhocodes/module-importer": "^1.0.1",
+ "@nodelib/fs.walk": "^1.2.8",
+ "@ungap/structured-clone": "^1.2.0",
+ "ajv": "^6.12.4",
+ "chalk": "^4.0.0",
+ "cross-spawn": "^7.0.2",
+ "debug": "^4.3.2",
+ "doctrine": "^3.0.0",
+ "escape-string-regexp": "^4.0.0",
+ "eslint-scope": "^7.2.2",
+ "eslint-visitor-keys": "^3.4.3",
+ "espree": "^9.6.1",
+ "esquery": "^1.4.2",
+ "esutils": "^2.0.2",
+ "fast-deep-equal": "^3.1.3",
+ "file-entry-cache": "^6.0.1",
+ "find-up": "^5.0.0",
+ "glob-parent": "^6.0.2",
+ "globals": "^13.19.0",
+ "graphemer": "^1.4.0",
+ "ignore": "^5.2.0",
+ "imurmurhash": "^0.1.4",
+ "is-glob": "^4.0.0",
+ "is-path-inside": "^3.0.3",
+ "js-yaml": "^4.1.0",
+ "json-stable-stringify-without-jsonify": "^1.0.1",
+ "levn": "^0.4.1",
+ "lodash.merge": "^4.6.2",
+ "minimatch": "^3.1.2",
+ "natural-compare": "^1.4.0",
+ "optionator": "^0.9.3",
+ "strip-ansi": "^6.0.1",
+ "text-table": "^0.2.0"
+ },
+ "bin": {
+ "eslint": "bin/eslint.js"
+ },
+ "engines": {
+ "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ }
+ },
+ "node_modules/eslint-scope": {
+ "version": "7.2.2",
+ "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz",
+ "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "esrecurse": "^4.3.0",
+ "estraverse": "^5.2.0"
+ },
+ "engines": {
+ "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ }
+ },
+ "node_modules/eslint-visitor-keys": {
+ "version": "3.4.3",
+ "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+ "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ }
+ },
+ "node_modules/eslint/node_modules/brace-expansion": {
+ "version": "1.1.12",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+ "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0",
+ "concat-map": "0.0.1"
+ }
+ },
+ "node_modules/eslint/node_modules/minimatch": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+ "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^1.1.7"
+ },
+ "engines": {
+ "node": "*"
+ }
+ },
+ "node_modules/espree": {
+ "version": "9.6.1",
+ "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz",
+ "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "acorn": "^8.9.0",
+ "acorn-jsx": "^5.3.2",
+ "eslint-visitor-keys": "^3.4.1"
+ },
+ "engines": {
+ "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ }
+ },
+ "node_modules/esprima": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+ "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+ "license": "BSD-2-Clause",
+ "bin": {
+ "esparse": "bin/esparse.js",
+ "esvalidate": "bin/esvalidate.js"
+ },
+ "engines": {
+ "node": ">=4"
+ }
+ },
+ "node_modules/esquery": {
+ "version": "1.6.0",
+ "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
+ "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "estraverse": "^5.1.0"
+ },
+ "engines": {
+ "node": ">=0.10"
+ }
+ },
+ "node_modules/esrecurse": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+ "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "estraverse": "^5.2.0"
+ },
+ "engines": {
+ "node": ">=4.0"
+ }
+ },
+ "node_modules/estraverse": {
+ "version": "5.3.0",
+ "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+ "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "engines": {
+ "node": ">=4.0"
+ }
+ },
+ "node_modules/esutils": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+ "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/etag": {
+ "version": "1.8.1",
+ "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+ "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/execa": {
+ "version": "5.1.1",
+ "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz",
+ "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "cross-spawn": "^7.0.3",
+ "get-stream": "^6.0.0",
+ "human-signals": "^2.1.0",
+ "is-stream": "^2.0.0",
+ "merge-stream": "^2.0.0",
+ "npm-run-path": "^4.0.1",
+ "onetime": "^5.1.2",
+ "signal-exit": "^3.0.3",
+ "strip-final-newline": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sindresorhus/execa?sponsor=1"
+ }
+ },
+ "node_modules/exit": {
+ "version": "0.1.2",
+ "resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz",
+ "integrity": "sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==",
+ "dev": true,
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/expect": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/expect/-/expect-29.7.0.tgz",
+ "integrity": "sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/expect-utils": "^29.7.0",
+ "jest-get-type": "^29.6.3",
+ "jest-matcher-utils": "^29.7.0",
+ "jest-message-util": "^29.7.0",
+ "jest-util": "^29.7.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/express": {
+ "version": "4.21.2",
+ "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz",
+ "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==",
+ "license": "MIT",
+ "dependencies": {
+ "accepts": "~1.3.8",
+ "array-flatten": "1.1.1",
+ "body-parser": "1.20.3",
+ "content-disposition": "0.5.4",
+ "content-type": "~1.0.4",
+ "cookie": "0.7.1",
+ "cookie-signature": "1.0.6",
+ "debug": "2.6.9",
+ "depd": "2.0.0",
+ "encodeurl": "~2.0.0",
+ "escape-html": "~1.0.3",
+ "etag": "~1.8.1",
+ "finalhandler": "1.3.1",
+ "fresh": "0.5.2",
+ "http-errors": "2.0.0",
+ "merge-descriptors": "1.0.3",
+ "methods": "~1.1.2",
+ "on-finished": "2.4.1",
+ "parseurl": "~1.3.3",
+ "path-to-regexp": "0.1.12",
+ "proxy-addr": "~2.0.7",
+ "qs": "6.13.0",
+ "range-parser": "~1.2.1",
+ "safe-buffer": "5.2.1",
+ "send": "0.19.0",
+ "serve-static": "1.16.2",
+ "setprototypeof": "1.2.0",
+ "statuses": "2.0.1",
+ "type-is": "~1.6.18",
+ "utils-merge": "1.0.1",
+ "vary": "~1.1.2"
+ },
+ "engines": {
+ "node": ">= 0.10.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/express"
+ }
+ },
+ "node_modules/express/node_modules/debug": {
+ "version": "2.6.9",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+ "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+ "license": "MIT",
+ "dependencies": {
+ "ms": "2.0.0"
+ }
+ },
+ "node_modules/express/node_modules/ms": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+ "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+ "license": "MIT"
+ },
+ "node_modules/fast-deep-equal": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+ "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+ "license": "MIT"
+ },
+ "node_modules/fast-glob": {
+ "version": "3.3.3",
+ "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
+ "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@nodelib/fs.stat": "^2.0.2",
+ "@nodelib/fs.walk": "^1.2.3",
+ "glob-parent": "^5.1.2",
+ "merge2": "^1.3.0",
+ "micromatch": "^4.0.8"
+ },
+ "engines": {
+ "node": ">=8.6.0"
+ }
+ },
+ "node_modules/fast-glob/node_modules/glob-parent": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+ "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "is-glob": "^4.0.1"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/fast-json-patch": {
+ "version": "2.2.1",
+ "resolved": "https://registry.npmjs.org/fast-json-patch/-/fast-json-patch-2.2.1.tgz",
+ "integrity": "sha512-4j5uBaTnsYAV5ebkidvxiLUYOwjQ+JSFljeqfTxCrH9bDmlCQaOJFS84oDJ2rAXZq2yskmk3ORfoP9DCwqFNig==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fast-deep-equal": "^2.0.1"
+ },
+ "engines": {
+ "node": ">= 0.4.0"
+ }
+ },
+ "node_modules/fast-json-patch/node_modules/fast-deep-equal": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz",
+ "integrity": "sha512-bCK/2Z4zLidyB4ReuIsvALH6w31YfAQDmXMqMx6FyfHqvBxtjC0eRumeSu4Bs3XtXwpyIywtSTrVT99BxY1f9w==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/fast-json-stable-stringify": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+ "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/fast-levenshtein": {
+ "version": "2.0.6",
+ "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+ "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/fast-safe-stringify": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.1.1.tgz",
+ "integrity": "sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/fast-uri": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz",
+ "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/fastify"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/fastify"
+ }
+ ],
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/fastq": {
+ "version": "1.19.1",
+ "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz",
+ "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "reusify": "^1.0.4"
+ }
+ },
+ "node_modules/fb-watchman": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.2.tgz",
+ "integrity": "sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "bser": "2.1.1"
+ }
+ },
+ "node_modules/fecha": {
+ "version": "4.2.3",
+ "resolved": "https://registry.npmjs.org/fecha/-/fecha-4.2.3.tgz",
+ "integrity": "sha512-OP2IUU6HeYKJi3i0z4A19kHMQoLVs4Hc+DPqqxI2h/DPZHTm/vjsfC6P0b4jCMy14XizLBqvndQ+UilD7707Jw==",
+ "license": "MIT"
+ },
+ "node_modules/fhirpath": {
+ "version": "4.6.0",
+ "resolved": "https://registry.npmjs.org/fhirpath/-/fhirpath-4.6.0.tgz",
+ "integrity": "sha512-nfK0+9mVLS/hyZNmwGlRV6EG8lll9VV5AGgAiXcCfSUms/M9R94JqyC34r3/Yjkp0ICuR70NH7Q7q9A2T91DzA==",
+ "hasInstallScript": true,
+ "license": "SEE LICENSE in LICENSE.md",
+ "dependencies": {
+ "@lhncbc/ucum-lhc": "^5.0.0",
+ "@loxjs/url-join": "^1.0.2",
+ "antlr4": "~4.9.3",
+ "commander": "^2.18.0",
+ "date-fns": "^1.30.1",
+ "js-yaml": "^3.13.1"
+ },
+ "bin": {
+ "fhirpath": "bin/fhirpath"
+ },
+ "engines": {
+ "node": ">=8.9.0"
+ }
+ },
+ "node_modules/fhirpath/node_modules/argparse": {
+ "version": "1.0.10",
+ "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+ "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+ "license": "MIT",
+ "dependencies": {
+ "sprintf-js": "~1.0.2"
+ }
+ },
+ "node_modules/fhirpath/node_modules/js-yaml": {
+ "version": "3.14.1",
+ "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
+ "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
+ "license": "MIT",
+ "dependencies": {
+ "argparse": "^1.0.7",
+ "esprima": "^4.0.0"
+ },
+ "bin": {
+ "js-yaml": "bin/js-yaml.js"
+ }
+ },
+ "node_modules/file-entry-cache": {
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz",
+ "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "flat-cache": "^3.0.4"
+ },
+ "engines": {
+ "node": "^10.12.0 || >=12.0.0"
+ }
+ },
+ "node_modules/filename-reserved-regex": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/filename-reserved-regex/-/filename-reserved-regex-2.0.0.tgz",
+ "integrity": "sha512-lc1bnsSr4L4Bdif8Xb/qrtokGbq5zlsms/CYH8PP+WtCkGNF65DPiQY8vG3SakEdRn8Dlnm+gW/qWKKjS5sZzQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=4"
+ }
+ },
+ "node_modules/filenamify": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/filenamify/-/filenamify-4.3.0.tgz",
+ "integrity": "sha512-hcFKyUG57yWGAzu1CMt/dPzYZuv+jAJUT85bL8mrXvNe6hWj6yEHEc4EdcgiA6Z3oi1/9wXJdZPXF2dZNgwgOg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "filename-reserved-regex": "^2.0.0",
+ "strip-outer": "^1.0.1",
+ "trim-repeated": "^1.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/fill-range": {
+ "version": "7.1.1",
+ "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+ "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "to-regex-range": "^5.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/finalhandler": {
+ "version": "1.3.1",
+ "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz",
+ "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==",
+ "license": "MIT",
+ "dependencies": {
+ "debug": "2.6.9",
+ "encodeurl": "~2.0.0",
+ "escape-html": "~1.0.3",
+ "on-finished": "2.4.1",
+ "parseurl": "~1.3.3",
+ "statuses": "2.0.1",
+ "unpipe": "~1.0.0"
+ },
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/finalhandler/node_modules/debug": {
+ "version": "2.6.9",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+ "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+ "license": "MIT",
+ "dependencies": {
+ "ms": "2.0.0"
+ }
+ },
+ "node_modules/finalhandler/node_modules/ms": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+ "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+ "license": "MIT"
+ },
+ "node_modules/find-cache-dir": {
+ "version": "3.3.2",
+ "resolved": "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-3.3.2.tgz",
+ "integrity": "sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "commondir": "^1.0.1",
+ "make-dir": "^3.0.2",
+ "pkg-dir": "^4.1.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/avajs/find-cache-dir?sponsor=1"
+ }
+ },
+ "node_modules/find-cache-dir/node_modules/make-dir": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz",
+ "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "semver": "^6.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/find-cache-dir/node_modules/semver": {
+ "version": "6.3.1",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+ "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ }
+ },
+ "node_modules/find-up": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+ "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "locate-path": "^6.0.0",
+ "path-exists": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/flat-cache": {
+ "version": "3.2.0",
+ "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz",
+ "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "flatted": "^3.2.9",
+ "keyv": "^4.5.3",
+ "rimraf": "^3.0.2"
+ },
+ "engines": {
+ "node": "^10.12.0 || >=12.0.0"
+ }
+ },
+ "node_modules/flatted": {
+ "version": "3.3.3",
+ "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
+ "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/fmlrunner": {
+ "resolved": "packages/fmlrunner",
+ "link": true
+ },
+ "node_modules/fmlrunner-mcp": {
+ "resolved": "packages/fmlrunner-mcp",
+ "link": true
+ },
+ "node_modules/fmlrunner-rest": {
+ "resolved": "packages/fmlrunner-rest",
+ "link": true
+ },
+ "node_modules/fn.name": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/fn.name/-/fn.name-1.1.0.tgz",
+ "integrity": "sha512-GRnmB5gPyJpAhTQdSZTSp9uaPSvl09KoYcMQtsB9rQoOmzs9dH6ffeccH+Z+cv6P68Hu5bC6JjRh4Ah/mHSNRw==",
+ "license": "MIT"
+ },
+ "node_modules/form-data": {
+ "version": "4.0.4",
+ "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
+ "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "asynckit": "^0.4.0",
+ "combined-stream": "^1.0.8",
+ "es-set-tostringtag": "^2.1.0",
+ "hasown": "^2.0.2",
+ "mime-types": "^2.1.12"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/formidable": {
+ "version": "2.1.5",
+ "resolved": "https://registry.npmjs.org/formidable/-/formidable-2.1.5.tgz",
+ "integrity": "sha512-Oz5Hwvwak/DCaXVVUtPn4oLMLLy1CdclLKO1LFgU7XzDpVMUU5UjlSLpGMocyQNNk8F6IJW9M/YdooSn2MRI+Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@paralleldrive/cuid2": "^2.2.2",
+ "dezalgo": "^1.0.4",
+ "once": "^1.4.0",
+ "qs": "^6.11.0"
+ },
+ "funding": {
+ "url": "https://ko-fi.com/tunnckoCore/commissions"
+ }
+ },
+ "node_modules/forwarded": {
+ "version": "0.2.0",
+ "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+ "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/fresh": {
+ "version": "0.5.2",
+ "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+ "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/fs-extra": {
+ "version": "11.3.1",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.1.tgz",
+ "integrity": "sha512-eXvGGwZ5CL17ZSwHWd3bbgk7UUpF6IFHtP57NYYakPvHOs8GDgDe5KJI36jIJzDkJ6eJjuzRA8eBQb6SkKue0g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=14.14"
+ }
+ },
+ "node_modules/fs-extra/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/fs.realpath": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+ "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+ "license": "ISC"
+ },
+ "node_modules/fsevents": {
+ "version": "2.3.3",
+ "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+ "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+ }
+ },
+ "node_modules/function-bind": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+ "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/gensync": {
+ "version": "1.0.0-beta.2",
+ "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+ "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/get-caller-file": {
+ "version": "2.0.5",
+ "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+ "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": "6.* || 8.* || >= 10.*"
+ }
+ },
+ "node_modules/get-intrinsic": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+ "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+ "license": "MIT",
+ "dependencies": {
+ "call-bind-apply-helpers": "^1.0.2",
+ "es-define-property": "^1.0.1",
+ "es-errors": "^1.3.0",
+ "es-object-atoms": "^1.1.1",
+ "function-bind": "^1.1.2",
+ "get-proto": "^1.0.1",
+ "gopd": "^1.2.0",
+ "has-symbols": "^1.1.0",
+ "hasown": "^2.0.2",
+ "math-intrinsics": "^1.1.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/get-package-type": {
+ "version": "0.1.0",
+ "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz",
+ "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8.0.0"
+ }
+ },
+ "node_modules/get-proto": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+ "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+ "license": "MIT",
+ "dependencies": {
+ "dunder-proto": "^1.0.1",
+ "es-object-atoms": "^1.0.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/get-stream": {
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz",
+ "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/gh-pages": {
+ "version": "6.3.0",
+ "resolved": "https://registry.npmjs.org/gh-pages/-/gh-pages-6.3.0.tgz",
+ "integrity": "sha512-Ot5lU6jK0Eb+sszG8pciXdjMXdBJ5wODvgjR+imihTqsUWF2K6dJ9HST55lgqcs8wWcw6o6wAsUzfcYRhJPXbA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "async": "^3.2.4",
+ "commander": "^13.0.0",
+ "email-addresses": "^5.0.0",
+ "filenamify": "^4.3.0",
+ "find-cache-dir": "^3.3.1",
+ "fs-extra": "^11.1.1",
+ "globby": "^11.1.0"
+ },
+ "bin": {
+ "gh-pages": "bin/gh-pages.js",
+ "gh-pages-clean": "bin/gh-pages-clean.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/gh-pages/node_modules/commander": {
+ "version": "13.1.0",
+ "resolved": "https://registry.npmjs.org/commander/-/commander-13.1.0.tgz",
+ "integrity": "sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/glob": {
+ "version": "7.2.3",
+ "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+ "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+ "deprecated": "Glob versions prior to v9 are no longer supported",
+ "license": "ISC",
+ "dependencies": {
+ "fs.realpath": "^1.0.0",
+ "inflight": "^1.0.4",
+ "inherits": "2",
+ "minimatch": "^3.1.1",
+ "once": "^1.3.0",
+ "path-is-absolute": "^1.0.0"
+ },
+ "engines": {
+ "node": "*"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/glob-parent": {
+ "version": "6.0.2",
+ "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+ "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "is-glob": "^4.0.3"
+ },
+ "engines": {
+ "node": ">=10.13.0"
+ }
+ },
+ "node_modules/glob/node_modules/brace-expansion": {
+ "version": "1.1.12",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+ "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0",
+ "concat-map": "0.0.1"
+ }
+ },
+ "node_modules/glob/node_modules/minimatch": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+ "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^1.1.7"
+ },
+ "engines": {
+ "node": "*"
+ }
+ },
+ "node_modules/globals": {
+ "version": "13.24.0",
+ "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz",
+ "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "type-fest": "^0.20.2"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/globby": {
+ "version": "11.1.0",
+ "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz",
+ "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "array-union": "^2.1.0",
+ "dir-glob": "^3.0.1",
+ "fast-glob": "^3.2.9",
+ "ignore": "^5.2.0",
+ "merge2": "^1.4.1",
+ "slash": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/gopd": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+ "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/graceful-fs": {
+ "version": "4.2.11",
+ "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+ "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+ "devOptional": true,
+ "license": "ISC"
+ },
+ "node_modules/graphemer": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
+ "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/handlebars": {
+ "version": "4.7.8",
+ "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.8.tgz",
+ "integrity": "sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "minimist": "^1.2.5",
+ "neo-async": "^2.6.2",
+ "source-map": "^0.6.1",
+ "wordwrap": "^1.0.0"
+ },
+ "bin": {
+ "handlebars": "bin/handlebars"
+ },
+ "engines": {
+ "node": ">=0.4.7"
+ },
+ "optionalDependencies": {
+ "uglify-js": "^3.1.4"
+ }
+ },
+ "node_modules/has-flag": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+ "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/has-symbols": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+ "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/has-tostringtag": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+ "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "has-symbols": "^1.0.3"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/hasown": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+ "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+ "license": "MIT",
+ "dependencies": {
+ "function-bind": "^1.1.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/html-escaper": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",
+ "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/http-errors": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+ "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+ "license": "MIT",
+ "dependencies": {
+ "depd": "2.0.0",
+ "inherits": "2.0.4",
+ "setprototypeof": "1.2.0",
+ "statuses": "2.0.1",
+ "toidentifier": "1.0.1"
+ },
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/human-signals": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz",
+ "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=10.17.0"
+ }
+ },
+ "node_modules/iconv-lite": {
+ "version": "0.4.24",
+ "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+ "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+ "license": "MIT",
+ "dependencies": {
+ "safer-buffer": ">= 2.1.2 < 3"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/ignore": {
+ "version": "5.3.2",
+ "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+ "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 4"
+ }
+ },
+ "node_modules/import-fresh": {
+ "version": "3.3.1",
+ "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+ "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "parent-module": "^1.0.0",
+ "resolve-from": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/import-local": {
+ "version": "3.2.0",
+ "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.2.0.tgz",
+ "integrity": "sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "pkg-dir": "^4.2.0",
+ "resolve-cwd": "^3.0.0"
+ },
+ "bin": {
+ "import-local-fixture": "fixtures/cli.js"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/imurmurhash": {
+ "version": "0.1.4",
+ "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+ "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.8.19"
+ }
+ },
+ "node_modules/inflight": {
+ "version": "1.0.6",
+ "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+ "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+ "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+ "license": "ISC",
+ "dependencies": {
+ "once": "^1.3.0",
+ "wrappy": "1"
+ }
+ },
+ "node_modules/inherits": {
+ "version": "2.0.4",
+ "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+ "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+ "license": "ISC"
+ },
+ "node_modules/ipaddr.js": {
+ "version": "1.9.1",
+ "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+ "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.10"
+ }
+ },
+ "node_modules/is-arrayish": {
+ "version": "0.2.1",
+ "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
+ "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/is-core-module": {
+ "version": "2.16.1",
+ "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
+ "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "hasown": "^2.0.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/is-extglob": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+ "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/is-finite": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/is-finite/-/is-finite-1.1.0.tgz",
+ "integrity": "sha512-cdyMtqX/BOqqNBBiKlIVkytNHm49MtMlYyn1zxzvJKWmFMlGzm+ry5BBfYyeY9YmNKbRSo/o7OX9w9ale0wg3w==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/is-fullwidth-code-point": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+ "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/is-generator-fn": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/is-generator-fn/-/is-generator-fn-2.1.0.tgz",
+ "integrity": "sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/is-glob": {
+ "version": "4.0.3",
+ "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+ "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "is-extglob": "^2.1.1"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/is-integer": {
+ "version": "1.0.7",
+ "resolved": "https://registry.npmjs.org/is-integer/-/is-integer-1.0.7.tgz",
+ "integrity": "sha512-RPQc/s9yBHSvpi+hs9dYiJ2cuFeU6x3TyyIp8O2H6SKEltIvJOzRj9ToyvcStDvPR/pS4rxgr1oBFajQjZ2Szg==",
+ "license": "WTFPL OR ISC",
+ "dependencies": {
+ "is-finite": "^1.0.0"
+ }
+ },
+ "node_modules/is-number": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+ "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.12.0"
+ }
+ },
+ "node_modules/is-path-inside": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz",
+ "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/is-stream": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
+ "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/isarray": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+ "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
+ "license": "MIT"
+ },
+ "node_modules/isexe": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+ "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/istanbul-lib-coverage": {
+ "version": "3.2.2",
+ "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz",
+ "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/istanbul-lib-instrument": {
+ "version": "6.0.3",
+ "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-6.0.3.tgz",
+ "integrity": "sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "@babel/core": "^7.23.9",
+ "@babel/parser": "^7.23.9",
+ "@istanbuljs/schema": "^0.1.3",
+ "istanbul-lib-coverage": "^3.2.0",
+ "semver": "^7.5.4"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/istanbul-lib-report": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz",
+ "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "istanbul-lib-coverage": "^3.0.0",
+ "make-dir": "^4.0.0",
+ "supports-color": "^7.1.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/istanbul-lib-source-maps": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz",
+ "integrity": "sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "debug": "^4.1.1",
+ "istanbul-lib-coverage": "^3.0.0",
+ "source-map": "^0.6.1"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/istanbul-reports": {
+ "version": "3.2.0",
+ "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz",
+ "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "html-escaper": "^2.0.0",
+ "istanbul-lib-report": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/jest": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest/-/jest-29.7.0.tgz",
+ "integrity": "sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/core": "^29.7.0",
+ "@jest/types": "^29.6.3",
+ "import-local": "^3.0.2",
+ "jest-cli": "^29.7.0"
+ },
+ "bin": {
+ "jest": "bin/jest.js"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ },
+ "peerDependencies": {
+ "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
+ },
+ "peerDependenciesMeta": {
+ "node-notifier": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/jest-changed-files": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-29.7.0.tgz",
+ "integrity": "sha512-fEArFiwf1BpQ+4bXSprcDc3/x4HSzL4al2tozwVpDFpsxALjLYdyiIK4e5Vz66GQJIbXJ82+35PtysofptNX2w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "execa": "^5.0.0",
+ "jest-util": "^29.7.0",
+ "p-limit": "^3.1.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-circus": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-circus/-/jest-circus-29.7.0.tgz",
+ "integrity": "sha512-3E1nCMgipcTkCocFwM90XXQab9bS+GMsjdpmPrlelaxwD93Ad8iVEjX/vvHPdLPnFf+L40u+5+iutRdA1N9myw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/environment": "^29.7.0",
+ "@jest/expect": "^29.7.0",
+ "@jest/test-result": "^29.7.0",
+ "@jest/types": "^29.6.3",
+ "@types/node": "*",
+ "chalk": "^4.0.0",
+ "co": "^4.6.0",
+ "dedent": "^1.0.0",
+ "is-generator-fn": "^2.0.0",
+ "jest-each": "^29.7.0",
+ "jest-matcher-utils": "^29.7.0",
+ "jest-message-util": "^29.7.0",
+ "jest-runtime": "^29.7.0",
+ "jest-snapshot": "^29.7.0",
+ "jest-util": "^29.7.0",
+ "p-limit": "^3.1.0",
+ "pretty-format": "^29.7.0",
+ "pure-rand": "^6.0.0",
+ "slash": "^3.0.0",
+ "stack-utils": "^2.0.3"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-cli": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-cli/-/jest-cli-29.7.0.tgz",
+ "integrity": "sha512-OVVobw2IubN/GSYsxETi+gOe7Ka59EFMR/twOU3Jb2GnKKeMGJB5SGUUrEz3SFVmJASUdZUzy83sLNNQ2gZslg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/core": "^29.7.0",
+ "@jest/test-result": "^29.7.0",
+ "@jest/types": "^29.6.3",
+ "chalk": "^4.0.0",
+ "create-jest": "^29.7.0",
+ "exit": "^0.1.2",
+ "import-local": "^3.0.2",
+ "jest-config": "^29.7.0",
+ "jest-util": "^29.7.0",
+ "jest-validate": "^29.7.0",
+ "yargs": "^17.3.1"
+ },
+ "bin": {
+ "jest": "bin/jest.js"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ },
+ "peerDependencies": {
+ "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0"
+ },
+ "peerDependenciesMeta": {
+ "node-notifier": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/jest-config": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-config/-/jest-config-29.7.0.tgz",
+ "integrity": "sha512-uXbpfeQ7R6TZBqI3/TxCU4q4ttk3u0PJeC+E0zbfSoSjq6bJ7buBPxzQPL0ifrkY4DNu4JUdk0ImlBUYi840eQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/core": "^7.11.6",
+ "@jest/test-sequencer": "^29.7.0",
+ "@jest/types": "^29.6.3",
+ "babel-jest": "^29.7.0",
+ "chalk": "^4.0.0",
+ "ci-info": "^3.2.0",
+ "deepmerge": "^4.2.2",
+ "glob": "^7.1.3",
+ "graceful-fs": "^4.2.9",
+ "jest-circus": "^29.7.0",
+ "jest-environment-node": "^29.7.0",
+ "jest-get-type": "^29.6.3",
+ "jest-regex-util": "^29.6.3",
+ "jest-resolve": "^29.7.0",
+ "jest-runner": "^29.7.0",
+ "jest-util": "^29.7.0",
+ "jest-validate": "^29.7.0",
+ "micromatch": "^4.0.4",
+ "parse-json": "^5.2.0",
+ "pretty-format": "^29.7.0",
+ "slash": "^3.0.0",
+ "strip-json-comments": "^3.1.1"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ },
+ "peerDependencies": {
+ "@types/node": "*",
+ "ts-node": ">=9.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/node": {
+ "optional": true
+ },
+ "ts-node": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/jest-diff": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-29.7.0.tgz",
+ "integrity": "sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "chalk": "^4.0.0",
+ "diff-sequences": "^29.6.3",
+ "jest-get-type": "^29.6.3",
+ "pretty-format": "^29.7.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-docblock": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-29.7.0.tgz",
+ "integrity": "sha512-q617Auw3A612guyaFgsbFeYpNP5t2aoUNLwBUbc/0kD1R4t9ixDbyFTHd1nok4epoVFpr7PmeWHrhvuV3XaJ4g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "detect-newline": "^3.0.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-each": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-each/-/jest-each-29.7.0.tgz",
+ "integrity": "sha512-gns+Er14+ZrEoC5fhOfYCY1LOHHr0TI+rQUHZS8Ttw2l7gl+80eHc/gFf2Ktkw0+SIACDTeWvpFcv3B04VembQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/types": "^29.6.3",
+ "chalk": "^4.0.0",
+ "jest-get-type": "^29.6.3",
+ "jest-util": "^29.7.0",
+ "pretty-format": "^29.7.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-environment-node": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-29.7.0.tgz",
+ "integrity": "sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/environment": "^29.7.0",
+ "@jest/fake-timers": "^29.7.0",
+ "@jest/types": "^29.6.3",
+ "@types/node": "*",
+ "jest-mock": "^29.7.0",
+ "jest-util": "^29.7.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-get-type": {
+ "version": "29.6.3",
+ "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.6.3.tgz",
+ "integrity": "sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-haste-map": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-29.7.0.tgz",
+ "integrity": "sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/types": "^29.6.3",
+ "@types/graceful-fs": "^4.1.3",
+ "@types/node": "*",
+ "anymatch": "^3.0.3",
+ "fb-watchman": "^2.0.0",
+ "graceful-fs": "^4.2.9",
+ "jest-regex-util": "^29.6.3",
+ "jest-util": "^29.7.0",
+ "jest-worker": "^29.7.0",
+ "micromatch": "^4.0.4",
+ "walker": "^1.0.8"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ },
+ "optionalDependencies": {
+ "fsevents": "^2.3.2"
+ }
+ },
+ "node_modules/jest-leak-detector": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-29.7.0.tgz",
+ "integrity": "sha512-kYA8IJcSYtST2BY9I+SMC32nDpBT3J2NvWJx8+JCuCdl/CR1I4EKUJROiP8XtCcxqgTTBGJNdbB1A8XRKbTetw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "jest-get-type": "^29.6.3",
+ "pretty-format": "^29.7.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-matcher-utils": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-29.7.0.tgz",
+ "integrity": "sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "chalk": "^4.0.0",
+ "jest-diff": "^29.7.0",
+ "jest-get-type": "^29.6.3",
+ "pretty-format": "^29.7.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-message-util": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-29.7.0.tgz",
+ "integrity": "sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/code-frame": "^7.12.13",
+ "@jest/types": "^29.6.3",
+ "@types/stack-utils": "^2.0.0",
+ "chalk": "^4.0.0",
+ "graceful-fs": "^4.2.9",
+ "micromatch": "^4.0.4",
+ "pretty-format": "^29.7.0",
+ "slash": "^3.0.0",
+ "stack-utils": "^2.0.3"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-mock": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-29.7.0.tgz",
+ "integrity": "sha512-ITOMZn+UkYS4ZFh83xYAOzWStloNzJFO2s8DWrE4lhtGD+AorgnbkiKERe4wQVBydIGPx059g6riW5Btp6Llnw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/types": "^29.6.3",
+ "@types/node": "*",
+ "jest-util": "^29.7.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-pnp-resolver": {
+ "version": "1.2.3",
+ "resolved": "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz",
+ "integrity": "sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ },
+ "peerDependencies": {
+ "jest-resolve": "*"
+ },
+ "peerDependenciesMeta": {
+ "jest-resolve": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/jest-regex-util": {
+ "version": "29.6.3",
+ "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-29.6.3.tgz",
+ "integrity": "sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-resolve": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-resolve/-/jest-resolve-29.7.0.tgz",
+ "integrity": "sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "chalk": "^4.0.0",
+ "graceful-fs": "^4.2.9",
+ "jest-haste-map": "^29.7.0",
+ "jest-pnp-resolver": "^1.2.2",
+ "jest-util": "^29.7.0",
+ "jest-validate": "^29.7.0",
+ "resolve": "^1.20.0",
+ "resolve.exports": "^2.0.0",
+ "slash": "^3.0.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-resolve-dependencies": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-29.7.0.tgz",
+ "integrity": "sha512-un0zD/6qxJ+S0et7WxeI3H5XSe9lTBBR7bOHCHXkKR6luG5mwDDlIzVQ0V5cZCuoTgEdcdwzTghYkTWfubi+nA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "jest-regex-util": "^29.6.3",
+ "jest-snapshot": "^29.7.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-runner": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-runner/-/jest-runner-29.7.0.tgz",
+ "integrity": "sha512-fsc4N6cPCAahybGBfTRcq5wFR6fpLznMg47sY5aDpsoejOcVYFb07AHuSnR0liMcPTgBsA3ZJL6kFOjPdoNipQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/console": "^29.7.0",
+ "@jest/environment": "^29.7.0",
+ "@jest/test-result": "^29.7.0",
+ "@jest/transform": "^29.7.0",
+ "@jest/types": "^29.6.3",
+ "@types/node": "*",
+ "chalk": "^4.0.0",
+ "emittery": "^0.13.1",
+ "graceful-fs": "^4.2.9",
+ "jest-docblock": "^29.7.0",
+ "jest-environment-node": "^29.7.0",
+ "jest-haste-map": "^29.7.0",
+ "jest-leak-detector": "^29.7.0",
+ "jest-message-util": "^29.7.0",
+ "jest-resolve": "^29.7.0",
+ "jest-runtime": "^29.7.0",
+ "jest-util": "^29.7.0",
+ "jest-watcher": "^29.7.0",
+ "jest-worker": "^29.7.0",
+ "p-limit": "^3.1.0",
+ "source-map-support": "0.5.13"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-runtime": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-runtime/-/jest-runtime-29.7.0.tgz",
+ "integrity": "sha512-gUnLjgwdGqW7B4LvOIkbKs9WGbn+QLqRQQ9juC6HndeDiezIwhDP+mhMwHWCEcfQ5RUXa6OPnFF8BJh5xegwwQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/environment": "^29.7.0",
+ "@jest/fake-timers": "^29.7.0",
+ "@jest/globals": "^29.7.0",
+ "@jest/source-map": "^29.6.3",
+ "@jest/test-result": "^29.7.0",
+ "@jest/transform": "^29.7.0",
+ "@jest/types": "^29.6.3",
+ "@types/node": "*",
+ "chalk": "^4.0.0",
+ "cjs-module-lexer": "^1.0.0",
+ "collect-v8-coverage": "^1.0.0",
+ "glob": "^7.1.3",
+ "graceful-fs": "^4.2.9",
+ "jest-haste-map": "^29.7.0",
+ "jest-message-util": "^29.7.0",
+ "jest-mock": "^29.7.0",
+ "jest-regex-util": "^29.6.3",
+ "jest-resolve": "^29.7.0",
+ "jest-snapshot": "^29.7.0",
+ "jest-util": "^29.7.0",
+ "slash": "^3.0.0",
+ "strip-bom": "^4.0.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-snapshot": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-29.7.0.tgz",
+ "integrity": "sha512-Rm0BMWtxBcioHr1/OX5YCP8Uov4riHvKPknOGs804Zg9JGZgmIBkbtlxJC/7Z4msKYVbIJtfU+tKb8xlYNfdkw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/core": "^7.11.6",
+ "@babel/generator": "^7.7.2",
+ "@babel/plugin-syntax-jsx": "^7.7.2",
+ "@babel/plugin-syntax-typescript": "^7.7.2",
+ "@babel/types": "^7.3.3",
+ "@jest/expect-utils": "^29.7.0",
+ "@jest/transform": "^29.7.0",
+ "@jest/types": "^29.6.3",
+ "babel-preset-current-node-syntax": "^1.0.0",
+ "chalk": "^4.0.0",
+ "expect": "^29.7.0",
+ "graceful-fs": "^4.2.9",
+ "jest-diff": "^29.7.0",
+ "jest-get-type": "^29.6.3",
+ "jest-matcher-utils": "^29.7.0",
+ "jest-message-util": "^29.7.0",
+ "jest-util": "^29.7.0",
+ "natural-compare": "^1.4.0",
+ "pretty-format": "^29.7.0",
+ "semver": "^7.5.3"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-util": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-29.7.0.tgz",
+ "integrity": "sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/types": "^29.6.3",
+ "@types/node": "*",
+ "chalk": "^4.0.0",
+ "ci-info": "^3.2.0",
+ "graceful-fs": "^4.2.9",
+ "picomatch": "^2.2.3"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-validate": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-29.7.0.tgz",
+ "integrity": "sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/types": "^29.6.3",
+ "camelcase": "^6.2.0",
+ "chalk": "^4.0.0",
+ "jest-get-type": "^29.6.3",
+ "leven": "^3.1.0",
+ "pretty-format": "^29.7.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-validate/node_modules/camelcase": {
+ "version": "6.3.0",
+ "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz",
+ "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/jest-watcher": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-29.7.0.tgz",
+ "integrity": "sha512-49Fg7WXkU3Vl2h6LbLtMQ/HyB6rXSIX7SqvBLQmssRBGN9I0PNvPmAmCWSOY6SOvrjhI/F7/bGAv9RtnsPA03g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/test-result": "^29.7.0",
+ "@jest/types": "^29.6.3",
+ "@types/node": "*",
+ "ansi-escapes": "^4.2.1",
+ "chalk": "^4.0.0",
+ "emittery": "^0.13.1",
+ "jest-util": "^29.7.0",
+ "string-length": "^4.0.1"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-worker": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-29.7.0.tgz",
+ "integrity": "sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*",
+ "jest-util": "^29.7.0",
+ "merge-stream": "^2.0.0",
+ "supports-color": "^8.0.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/jest-worker/node_modules/supports-color": {
+ "version": "8.1.1",
+ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
+ "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "has-flag": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/supports-color?sponsor=1"
+ }
+ },
+ "node_modules/js-tokens": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+ "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/js-yaml": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+ "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "argparse": "^2.0.1"
+ },
+ "bin": {
+ "js-yaml": "bin/js-yaml.js"
+ }
+ },
+ "node_modules/jsesc": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+ "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "jsesc": "bin/jsesc"
+ },
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/json-buffer": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+ "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/json-parse-even-better-errors": {
+ "version": "2.3.1",
+ "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+ "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/json-schema-migrate": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/json-schema-migrate/-/json-schema-migrate-2.0.0.tgz",
+ "integrity": "sha512-r38SVTtojDRp4eD6WsCqiE0eNDt4v1WalBXb9cyZYw9ai5cGtBwzRNWjHzJl38w6TxFkXAIA7h+fyX3tnrAFhQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ajv": "^8.0.0"
+ }
+ },
+ "node_modules/json-schema-migrate/node_modules/ajv": {
+ "version": "8.17.1",
+ "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
+ "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fast-deep-equal": "^3.1.3",
+ "fast-uri": "^3.0.1",
+ "json-schema-traverse": "^1.0.0",
+ "require-from-string": "^2.0.2"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/epoberezkin"
+ }
+ },
+ "node_modules/json-schema-migrate/node_modules/json-schema-traverse": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+ "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/json-schema-traverse": {
+ "version": "0.4.1",
+ "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+ "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/json-stable-stringify-without-jsonify": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+ "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/json5": {
+ "version": "2.2.3",
+ "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+ "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "json5": "lib/cli.js"
+ },
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/jsonfile": {
+ "version": "2.4.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-2.4.0.tgz",
+ "integrity": "sha512-PKllAqbgLgxHaj8TElYymKCAgrASebJrWpTnEkOaTowt23VKXXN0sUeriJ+eh7y6ufb/CC5ap11pz71/cM0hUw==",
+ "license": "MIT",
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/keyv": {
+ "version": "4.5.4",
+ "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+ "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "json-buffer": "3.0.1"
+ }
+ },
+ "node_modules/kleur": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz",
+ "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/kuler": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/kuler/-/kuler-2.0.0.tgz",
+ "integrity": "sha512-Xq9nH7KlWZmXAtodXDDRE7vs6DU1gTU8zYDHDiWLSip45Egwq3plLHzPn27NgvzL2r1LMPC1vdqh98sQxtqj4A==",
+ "license": "MIT"
+ },
+ "node_modules/leven": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz",
+ "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/levn": {
+ "version": "0.4.1",
+ "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+ "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "prelude-ls": "^1.2.1",
+ "type-check": "~0.4.0"
+ },
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/lines-and-columns": {
+ "version": "1.2.4",
+ "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+ "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/locate-path": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+ "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "p-locate": "^5.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/lodash": {
+ "version": "4.17.21",
+ "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+ "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/lodash.get": {
+ "version": "4.4.2",
+ "resolved": "https://registry.npmjs.org/lodash.get/-/lodash.get-4.4.2.tgz",
+ "integrity": "sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==",
+ "deprecated": "This package is deprecated. Use the optional chaining (?.) operator instead.",
+ "license": "MIT"
+ },
+ "node_modules/lodash.memoize": {
+ "version": "4.1.2",
+ "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz",
+ "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/lodash.merge": {
+ "version": "4.6.2",
+ "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+ "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/logform": {
+ "version": "2.7.0",
+ "resolved": "https://registry.npmjs.org/logform/-/logform-2.7.0.tgz",
+ "integrity": "sha512-TFYA4jnP7PVbmlBIfhlSe+WKxs9dklXMTEGcBCIvLhE/Tn3H6Gk1norupVW7m5Cnd4bLcr08AytbyV/xj7f/kQ==",
+ "license": "MIT",
+ "dependencies": {
+ "@colors/colors": "1.6.0",
+ "@types/triple-beam": "^1.3.2",
+ "fecha": "^4.2.0",
+ "ms": "^2.1.1",
+ "safe-stable-stringify": "^2.3.1",
+ "triple-beam": "^1.3.0"
+ },
+ "engines": {
+ "node": ">= 12.0.0"
+ }
+ },
+ "node_modules/lru-cache": {
+ "version": "5.1.1",
+ "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+ "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "yallist": "^3.0.2"
+ }
+ },
+ "node_modules/make-dir": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz",
+ "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "semver": "^7.5.3"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/make-error": {
+ "version": "1.3.6",
+ "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz",
+ "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/makeerror": {
+ "version": "1.0.12",
+ "resolved": "https://registry.npmjs.org/makeerror/-/makeerror-1.0.12.tgz",
+ "integrity": "sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "tmpl": "1.0.5"
+ }
+ },
+ "node_modules/math-intrinsics": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+ "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/media-typer": {
+ "version": "0.3.0",
+ "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+ "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/merge-descriptors": {
+ "version": "1.0.3",
+ "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+ "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/merge-stream": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
+ "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/merge2": {
+ "version": "1.4.1",
+ "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+ "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/methods": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+ "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/micromatch": {
+ "version": "4.0.8",
+ "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+ "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "braces": "^3.0.3",
+ "picomatch": "^2.3.1"
+ },
+ "engines": {
+ "node": ">=8.6"
+ }
+ },
+ "node_modules/mime": {
+ "version": "1.6.0",
+ "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+ "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+ "license": "MIT",
+ "bin": {
+ "mime": "cli.js"
+ },
+ "engines": {
+ "node": ">=4"
+ }
+ },
+ "node_modules/mime-db": {
+ "version": "1.52.0",
+ "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+ "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/mime-types": {
+ "version": "2.1.35",
+ "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+ "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+ "license": "MIT",
+ "dependencies": {
+ "mime-db": "1.52.0"
+ },
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/mimic-fn": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
+ "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/minimatch": {
+ "version": "9.0.3",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz",
+ "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^2.0.1"
+ },
+ "engines": {
+ "node": ">=16 || 14 >=14.17"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/minimist": {
+ "version": "1.2.8",
+ "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+ "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/ms": {
+ "version": "2.1.3",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+ "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+ "license": "MIT"
+ },
+ "node_modules/natural-compare": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+ "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/negotiator": {
+ "version": "0.6.3",
+ "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+ "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/neo-async": {
+ "version": "2.6.2",
+ "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz",
+ "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/node-int64": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz",
+ "integrity": "sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/node-releases": {
+ "version": "2.0.20",
+ "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.20.tgz",
+ "integrity": "sha512-7gK6zSXEH6neM212JgfYFXe+GmZQM+fia5SsusuBIUgnPheLFBmIPhtFoAQRj8/7wASYQnbDlHPVwY0BefoFgA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/normalize-path": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+ "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/npm-run-path": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz",
+ "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "path-key": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/object-assign": {
+ "version": "4.1.1",
+ "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+ "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/object-inspect": {
+ "version": "1.13.4",
+ "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+ "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/on-finished": {
+ "version": "2.4.1",
+ "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+ "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+ "license": "MIT",
+ "dependencies": {
+ "ee-first": "1.1.1"
+ },
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/once": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+ "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+ "license": "ISC",
+ "dependencies": {
+ "wrappy": "1"
+ }
+ },
+ "node_modules/one-time": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/one-time/-/one-time-1.0.0.tgz",
+ "integrity": "sha512-5DXOiRKwuSEcQ/l0kGCF6Q3jcADFv5tSmRaJck/OqkVFcOzutB134KRSfF0xDrL39MNnqxbHBbUUcjZIhTgb2g==",
+ "license": "MIT",
+ "dependencies": {
+ "fn.name": "1.x.x"
+ }
+ },
+ "node_modules/onetime": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz",
+ "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "mimic-fn": "^2.1.0"
+ },
+ "engines": {
+ "node": ">=6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/optionator": {
+ "version": "0.9.4",
+ "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+ "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "deep-is": "^0.1.3",
+ "fast-levenshtein": "^2.0.6",
+ "levn": "^0.4.1",
+ "prelude-ls": "^1.2.1",
+ "type-check": "^0.4.0",
+ "word-wrap": "^1.2.5"
+ },
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/p-limit": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+ "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "yocto-queue": "^0.1.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/p-locate": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+ "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "p-limit": "^3.0.2"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/p-try": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
+ "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/parent-module": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+ "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "callsites": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/parse-json": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
+ "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/code-frame": "^7.0.0",
+ "error-ex": "^1.3.1",
+ "json-parse-even-better-errors": "^2.3.0",
+ "lines-and-columns": "^1.1.6"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/parseurl": {
+ "version": "1.3.3",
+ "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+ "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/path-exists": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+ "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/path-is-absolute": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+ "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/path-key": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+ "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/path-parse": {
+ "version": "1.0.7",
+ "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+ "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/path-to-regexp": {
+ "version": "0.1.12",
+ "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
+ "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==",
+ "license": "MIT"
+ },
+ "node_modules/path-type": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
+ "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/picocolors": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+ "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/picomatch": {
+ "version": "2.3.1",
+ "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+ "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8.6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/jonschlinkert"
+ }
+ },
+ "node_modules/pirates": {
+ "version": "4.0.7",
+ "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz",
+ "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/pkg-dir": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz",
+ "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "find-up": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/pkg-dir/node_modules/find-up": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz",
+ "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "locate-path": "^5.0.0",
+ "path-exists": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/pkg-dir/node_modules/locate-path": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz",
+ "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "p-locate": "^4.1.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/pkg-dir/node_modules/p-limit": {
+ "version": "2.3.0",
+ "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
+ "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "p-try": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/pkg-dir/node_modules/p-locate": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz",
+ "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "p-limit": "^2.2.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/prelude-ls": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+ "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/pretty-format": {
+ "version": "29.7.0",
+ "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-29.7.0.tgz",
+ "integrity": "sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jest/schemas": "^29.6.3",
+ "ansi-styles": "^5.0.0",
+ "react-is": "^18.0.0"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+ }
+ },
+ "node_modules/pretty-format/node_modules/ansi-styles": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+ "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+ }
+ },
+ "node_modules/process-nextick-args": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+ "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+ "license": "MIT"
+ },
+ "node_modules/prompts": {
+ "version": "2.4.2",
+ "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz",
+ "integrity": "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "kleur": "^3.0.3",
+ "sisteransi": "^1.0.5"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/proxy-addr": {
+ "version": "2.0.7",
+ "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+ "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+ "license": "MIT",
+ "dependencies": {
+ "forwarded": "0.2.0",
+ "ipaddr.js": "1.9.1"
+ },
+ "engines": {
+ "node": ">= 0.10"
+ }
+ },
+ "node_modules/punycode": {
+ "version": "2.3.1",
+ "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+ "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/pure-rand": {
+ "version": "6.1.0",
+ "resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-6.1.0.tgz",
+ "integrity": "sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "individual",
+ "url": "https://github.com/sponsors/dubzzz"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/fast-check"
+ }
+ ],
+ "license": "MIT"
+ },
+ "node_modules/qs": {
+ "version": "6.13.0",
+ "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
+ "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "side-channel": "^1.0.6"
+ },
+ "engines": {
+ "node": ">=0.6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/queue-microtask": {
+ "version": "1.2.3",
+ "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+ "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "MIT"
+ },
+ "node_modules/range-parser": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+ "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/raw-body": {
+ "version": "2.5.2",
+ "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz",
+ "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==",
+ "license": "MIT",
+ "dependencies": {
+ "bytes": "3.1.2",
+ "http-errors": "2.0.0",
+ "iconv-lite": "0.4.24",
+ "unpipe": "1.0.0"
+ },
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/react-is": {
+ "version": "18.3.1",
+ "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
+ "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/readable-stream": {
+ "version": "2.3.8",
+ "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+ "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+ "license": "MIT",
+ "dependencies": {
+ "core-util-is": "~1.0.0",
+ "inherits": "~2.0.3",
+ "isarray": "~1.0.0",
+ "process-nextick-args": "~2.0.0",
+ "safe-buffer": "~5.1.1",
+ "string_decoder": "~1.1.1",
+ "util-deprecate": "~1.0.1"
+ }
+ },
+ "node_modules/readable-stream/node_modules/safe-buffer": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+ "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+ "license": "MIT"
+ },
+ "node_modules/require-directory": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+ "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/require-from-string": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+ "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/resolve": {
+ "version": "1.22.10",
+ "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz",
+ "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "is-core-module": "^2.16.0",
+ "path-parse": "^1.0.7",
+ "supports-preserve-symlinks-flag": "^1.0.0"
+ },
+ "bin": {
+ "resolve": "bin/resolve"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/resolve-cwd": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz",
+ "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "resolve-from": "^5.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/resolve-cwd/node_modules/resolve-from": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz",
+ "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/resolve-from": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+ "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=4"
+ }
+ },
+ "node_modules/resolve.exports": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/resolve.exports/-/resolve.exports-2.0.3.tgz",
+ "integrity": "sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/reusify": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
+ "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "iojs": ">=1.0.0",
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/rimraf": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
+ "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
+ "deprecated": "Rimraf versions prior to v4 are no longer supported",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "glob": "^7.1.3"
+ },
+ "bin": {
+ "rimraf": "bin.js"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/run-parallel": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+ "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "queue-microtask": "^1.2.2"
+ }
+ },
+ "node_modules/rxjs": {
+ "version": "7.8.2",
+ "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.2.tgz",
+ "integrity": "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "tslib": "^2.1.0"
+ }
+ },
+ "node_modules/safe-buffer": {
+ "version": "5.2.1",
+ "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+ "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "MIT"
+ },
+ "node_modules/safe-stable-stringify": {
+ "version": "2.5.0",
+ "resolved": "https://registry.npmjs.org/safe-stable-stringify/-/safe-stable-stringify-2.5.0.tgz",
+ "integrity": "sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/safer-buffer": {
+ "version": "2.1.2",
+ "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+ "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+ "license": "MIT"
+ },
+ "node_modules/sax": {
+ "version": "1.1.6",
+ "resolved": "https://registry.npmjs.org/sax/-/sax-1.1.6.tgz",
+ "integrity": "sha512-8zci48uUQyfqynGDSkUMD7FCJB96hwLnlZOXlgs1l3TX+LW27t3psSWKUxC0fxVgA86i8tL4NwGcY1h/6t3ESg==",
+ "license": "ISC"
+ },
+ "node_modules/semver": {
+ "version": "7.7.2",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
+ "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/send": {
+ "version": "0.19.0",
+ "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz",
+ "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==",
+ "license": "MIT",
+ "dependencies": {
+ "debug": "2.6.9",
+ "depd": "2.0.0",
+ "destroy": "1.2.0",
+ "encodeurl": "~1.0.2",
+ "escape-html": "~1.0.3",
+ "etag": "~1.8.1",
+ "fresh": "0.5.2",
+ "http-errors": "2.0.0",
+ "mime": "1.6.0",
+ "ms": "2.1.3",
+ "on-finished": "2.4.1",
+ "range-parser": "~1.2.1",
+ "statuses": "2.0.1"
+ },
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/send/node_modules/debug": {
+ "version": "2.6.9",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+ "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+ "license": "MIT",
+ "dependencies": {
+ "ms": "2.0.0"
+ }
+ },
+ "node_modules/send/node_modules/debug/node_modules/ms": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+ "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+ "license": "MIT"
+ },
+ "node_modules/send/node_modules/encodeurl": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+ "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/serve-static": {
+ "version": "1.16.2",
+ "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz",
+ "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==",
+ "license": "MIT",
+ "dependencies": {
+ "encodeurl": "~2.0.0",
+ "escape-html": "~1.0.3",
+ "parseurl": "~1.3.3",
+ "send": "0.19.0"
+ },
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/setprototypeof": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+ "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+ "license": "ISC"
+ },
+ "node_modules/shebang-command": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+ "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "shebang-regex": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/shebang-regex": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+ "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/shell-quote": {
+ "version": "1.8.3",
+ "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.3.tgz",
+ "integrity": "sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/side-channel": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+ "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0",
+ "object-inspect": "^1.13.3",
+ "side-channel-list": "^1.0.0",
+ "side-channel-map": "^1.0.1",
+ "side-channel-weakmap": "^1.0.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/side-channel-list": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+ "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0",
+ "object-inspect": "^1.13.3"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/side-channel-map": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+ "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+ "license": "MIT",
+ "dependencies": {
+ "call-bound": "^1.0.2",
+ "es-errors": "^1.3.0",
+ "get-intrinsic": "^1.2.5",
+ "object-inspect": "^1.13.3"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/side-channel-weakmap": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+ "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+ "license": "MIT",
+ "dependencies": {
+ "call-bound": "^1.0.2",
+ "es-errors": "^1.3.0",
+ "get-intrinsic": "^1.2.5",
+ "object-inspect": "^1.13.3",
+ "side-channel-map": "^1.0.1"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/signal-exit": {
+ "version": "3.0.7",
+ "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+ "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/simple-swizzle": {
+ "version": "0.2.2",
+ "resolved": "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.2.tgz",
+ "integrity": "sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==",
+ "license": "MIT",
+ "dependencies": {
+ "is-arrayish": "^0.3.1"
+ }
+ },
+ "node_modules/simple-swizzle/node_modules/is-arrayish": {
+ "version": "0.3.2",
+ "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.3.2.tgz",
+ "integrity": "sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==",
+ "license": "MIT"
+ },
+ "node_modules/sisteransi": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz",
+ "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/slash": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
+ "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/source-map": {
+ "version": "0.6.1",
+ "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+ "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/source-map-support": {
+ "version": "0.5.13",
+ "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.13.tgz",
+ "integrity": "sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "buffer-from": "^1.0.0",
+ "source-map": "^0.6.0"
+ }
+ },
+ "node_modules/spawn-command": {
+ "version": "0.0.2",
+ "resolved": "https://registry.npmjs.org/spawn-command/-/spawn-command-0.0.2.tgz",
+ "integrity": "sha512-zC8zGoGkmc8J9ndvml8Xksr1Amk9qBujgbF0JAIWO7kXr43w0h/0GJNM/Vustixu+YE8N/MTrQ7N31FvHUACxQ==",
+ "dev": true
+ },
+ "node_modules/sprintf-js": {
+ "version": "1.0.3",
+ "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
+ "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/stack-trace": {
+ "version": "0.0.10",
+ "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.10.tgz",
+ "integrity": "sha512-KGzahc7puUKkzyMt+IqAep+TVNbKP+k2Lmwhub39m1AsTSkaDutx56aDCo+HLDzf/D26BIHTJWNiTG1KAJiQCg==",
+ "license": "MIT",
+ "engines": {
+ "node": "*"
+ }
+ },
+ "node_modules/stack-utils": {
+ "version": "2.0.6",
+ "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz",
+ "integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "escape-string-regexp": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/stack-utils/node_modules/escape-string-regexp": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz",
+ "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/statuses": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+ "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/stream": {
+ "version": "0.0.2",
+ "resolved": "https://registry.npmjs.org/stream/-/stream-0.0.2.tgz",
+ "integrity": "sha512-gCq3NDI2P35B2n6t76YJuOp7d6cN/C7Rt0577l91wllh0sY9ZBuw9KaSGqH/b0hzn3CWWJbpbW0W0WvQ1H/Q7g==",
+ "license": "MIT",
+ "dependencies": {
+ "emitter-component": "^1.1.1"
+ }
+ },
+ "node_modules/stream-transform": {
+ "version": "0.1.2",
+ "resolved": "https://registry.npmjs.org/stream-transform/-/stream-transform-0.1.2.tgz",
+ "integrity": "sha512-3HXId/0W8sktQnQM6rOZf2LuDDMbakMgAjpViLk758/h0br+iGqZFFfUxxJSqEvGvT742PyFr4v/TBXUtowdCg==",
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/string_decoder": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+ "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+ "license": "MIT",
+ "dependencies": {
+ "safe-buffer": "~5.1.0"
+ }
+ },
+ "node_modules/string_decoder/node_modules/safe-buffer": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+ "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+ "license": "MIT"
+ },
+ "node_modules/string-length": {
+ "version": "4.0.2",
+ "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz",
+ "integrity": "sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "char-regex": "^1.0.2",
+ "strip-ansi": "^6.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/string-to-stream": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/string-to-stream/-/string-to-stream-1.1.1.tgz",
+ "integrity": "sha512-QySF2+3Rwq0SdO3s7BAp4x+c3qsClpPQ6abAmb0DGViiSBAkT5kL6JT2iyzEVP+T1SmzHrQD1TwlP9QAHCc+Sw==",
+ "license": "MIT",
+ "dependencies": {
+ "inherits": "^2.0.1",
+ "readable-stream": "^2.1.0"
+ }
+ },
+ "node_modules/string-width": {
+ "version": "4.2.3",
+ "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+ "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "emoji-regex": "^8.0.0",
+ "is-fullwidth-code-point": "^3.0.0",
+ "strip-ansi": "^6.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/strip-ansi": {
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+ "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-regex": "^5.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/strip-bom": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz",
+ "integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/strip-final-newline": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz",
+ "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/strip-json-comments": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+ "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/strip-outer": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/strip-outer/-/strip-outer-1.0.1.tgz",
+ "integrity": "sha512-k55yxKHwaXnpYGsOzg4Vl8+tDrWylxDEpknGjhTiZB8dFRU5rTo9CAzeycivxV3s+zlTKwrs6WxMxR95n26kwg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "escape-string-regexp": "^1.0.2"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/strip-outer/node_modules/escape-string-regexp": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+ "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.8.0"
+ }
+ },
+ "node_modules/superagent": {
+ "version": "8.1.2",
+ "resolved": "https://registry.npmjs.org/superagent/-/superagent-8.1.2.tgz",
+ "integrity": "sha512-6WTxW1EB6yCxV5VFOIPQruWGHqc3yI7hEmZK6h+pyk69Lk/Ut7rLUY6W/ONF2MjBuGjvmMiIpsrVJ2vjrHlslA==",
+ "deprecated": "Please upgrade to superagent v10.2.2+, see release notes at https://github.com/forwardemail/superagent/releases/tag/v10.2.2 - maintenance is supported by Forward Email @ https://forwardemail.net",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "component-emitter": "^1.3.0",
+ "cookiejar": "^2.1.4",
+ "debug": "^4.3.4",
+ "fast-safe-stringify": "^2.1.1",
+ "form-data": "^4.0.0",
+ "formidable": "^2.1.2",
+ "methods": "^1.1.2",
+ "mime": "2.6.0",
+ "qs": "^6.11.0",
+ "semver": "^7.3.8"
+ },
+ "engines": {
+ "node": ">=6.4.0 <13 || >=14"
+ }
+ },
+ "node_modules/superagent/node_modules/mime": {
+ "version": "2.6.0",
+ "resolved": "https://registry.npmjs.org/mime/-/mime-2.6.0.tgz",
+ "integrity": "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "mime": "cli.js"
+ },
+ "engines": {
+ "node": ">=4.0.0"
+ }
+ },
+ "node_modules/supertest": {
+ "version": "6.3.4",
+ "resolved": "https://registry.npmjs.org/supertest/-/supertest-6.3.4.tgz",
+ "integrity": "sha512-erY3HFDG0dPnhw4U+udPfrzXa4xhSG+n4rxfRuZWCUvjFWwKl+OxWf/7zk50s84/fAAs7vf5QAb9uRa0cCykxw==",
+ "deprecated": "Please upgrade to supertest v7.1.3+, see release notes at https://github.com/forwardemail/supertest/releases/tag/v7.1.3 - maintenance is supported by Forward Email @ https://forwardemail.net",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "methods": "^1.1.2",
+ "superagent": "^8.1.2"
+ },
+ "engines": {
+ "node": ">=6.4.0"
+ }
+ },
+ "node_modules/supports-color": {
+ "version": "7.2.0",
+ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+ "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "has-flag": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/supports-preserve-symlinks-flag": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+ "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/swagger-ui-dist": {
+ "version": "5.29.0",
+ "resolved": "https://registry.npmjs.org/swagger-ui-dist/-/swagger-ui-dist-5.29.0.tgz",
+ "integrity": "sha512-gqs7Md3AxP4mbpXAq31o5QW+wGUZsUzVatg70yXpUR245dfIis5jAzufBd+UQM/w2xSfrhvA1eqsrgnl2PbezQ==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@scarf/scarf": "=1.4.0"
+ }
+ },
+ "node_modules/swagger-ui-express": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/swagger-ui-express/-/swagger-ui-express-5.0.1.tgz",
+ "integrity": "sha512-SrNU3RiBGTLLmFU8GIJdOdanJTl4TOmT27tt3bWWHppqYmAZ6IDuEuBvMU6nZq0zLEe6b/1rACXCgLZqO6ZfrA==",
+ "license": "MIT",
+ "dependencies": {
+ "swagger-ui-dist": ">=5.0.0"
+ },
+ "engines": {
+ "node": ">= v0.10.32"
+ },
+ "peerDependencies": {
+ "express": ">=4.0.0 || >=5.0.0-beta"
+ }
+ },
+ "node_modules/test-exclude": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz",
+ "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "@istanbuljs/schema": "^0.1.2",
+ "glob": "^7.1.4",
+ "minimatch": "^3.0.4"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/test-exclude/node_modules/brace-expansion": {
+ "version": "1.1.12",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+ "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0",
+ "concat-map": "0.0.1"
+ }
+ },
+ "node_modules/test-exclude/node_modules/minimatch": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+ "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^1.1.7"
+ },
+ "engines": {
+ "node": "*"
+ }
+ },
+ "node_modules/text-hex": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/text-hex/-/text-hex-1.0.0.tgz",
+ "integrity": "sha512-uuVGNWzgJ4yhRaNSiubPY7OjISw4sw4E5Uv0wbjp+OzcbmVU/rsT8ujgcXJhn9ypzsgr5vlzpPqP+MBBKcGvbg==",
+ "license": "MIT"
+ },
+ "node_modules/text-table": {
+ "version": "0.2.0",
+ "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
+ "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/tmpl": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/tmpl/-/tmpl-1.0.5.tgz",
+ "integrity": "sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==",
+ "dev": true,
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/to-regex-range": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+ "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "is-number": "^7.0.0"
+ },
+ "engines": {
+ "node": ">=8.0"
+ }
+ },
+ "node_modules/toidentifier": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+ "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.6"
+ }
+ },
+ "node_modules/tree-kill": {
+ "version": "1.2.2",
+ "resolved": "https://registry.npmjs.org/tree-kill/-/tree-kill-1.2.2.tgz",
+ "integrity": "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "tree-kill": "cli.js"
+ }
+ },
+ "node_modules/trim-repeated": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/trim-repeated/-/trim-repeated-1.0.0.tgz",
+ "integrity": "sha512-pkonvlKk8/ZuR0D5tLW8ljt5I8kmxp2XKymhepUeOdCEfKpZaktSArkLHZt76OB1ZvO9bssUsDty4SWhLvZpLg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "escape-string-regexp": "^1.0.2"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/trim-repeated/node_modules/escape-string-regexp": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+ "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.8.0"
+ }
+ },
+ "node_modules/triple-beam": {
+ "version": "1.4.1",
+ "resolved": "https://registry.npmjs.org/triple-beam/-/triple-beam-1.4.1.tgz",
+ "integrity": "sha512-aZbgViZrg1QNcG+LULa7nhZpJTZSLm/mXnHXnbAbjmN5aSa0y7V+wvv6+4WaBtpISJzThKy+PIPxc1Nq1EJ9mg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 14.0.0"
+ }
+ },
+ "node_modules/ts-api-utils": {
+ "version": "1.4.3",
+ "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.4.3.tgz",
+ "integrity": "sha512-i3eMG77UTMD0hZhgRS562pv83RC6ukSAC2GMNWc+9dieh/+jDM5u5YG+NHX6VNDRHQcHwmsTHctP9LhbC3WxVw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=16"
+ },
+ "peerDependencies": {
+ "typescript": ">=4.2.0"
+ }
+ },
+ "node_modules/ts-jest": {
+ "version": "29.4.1",
+ "resolved": "https://registry.npmjs.org/ts-jest/-/ts-jest-29.4.1.tgz",
+ "integrity": "sha512-SaeUtjfpg9Uqu8IbeDKtdaS0g8lS6FT6OzM3ezrDfErPJPHNDo/Ey+VFGP1bQIDfagYDLyRpd7O15XpG1Es2Uw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "bs-logger": "^0.2.6",
+ "fast-json-stable-stringify": "^2.1.0",
+ "handlebars": "^4.7.8",
+ "json5": "^2.2.3",
+ "lodash.memoize": "^4.1.2",
+ "make-error": "^1.3.6",
+ "semver": "^7.7.2",
+ "type-fest": "^4.41.0",
+ "yargs-parser": "^21.1.1"
+ },
+ "bin": {
+ "ts-jest": "cli.js"
+ },
+ "engines": {
+ "node": "^14.15.0 || ^16.10.0 || ^18.0.0 || >=20.0.0"
+ },
+ "peerDependencies": {
+ "@babel/core": ">=7.0.0-beta.0 <8",
+ "@jest/transform": "^29.0.0 || ^30.0.0",
+ "@jest/types": "^29.0.0 || ^30.0.0",
+ "babel-jest": "^29.0.0 || ^30.0.0",
+ "jest": "^29.0.0 || ^30.0.0",
+ "jest-util": "^29.0.0 || ^30.0.0",
+ "typescript": ">=4.3 <6"
+ },
+ "peerDependenciesMeta": {
+ "@babel/core": {
+ "optional": true
+ },
+ "@jest/transform": {
+ "optional": true
+ },
+ "@jest/types": {
+ "optional": true
+ },
+ "babel-jest": {
+ "optional": true
+ },
+ "esbuild": {
+ "optional": true
+ },
+ "jest-util": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/ts-jest/node_modules/type-fest": {
+ "version": "4.41.0",
+ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz",
+ "integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==",
+ "dev": true,
+ "license": "(MIT OR CC0-1.0)",
+ "engines": {
+ "node": ">=16"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/tslib": {
+ "version": "2.8.1",
+ "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+ "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+ "dev": true,
+ "license": "0BSD"
+ },
+ "node_modules/type-check": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+ "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "prelude-ls": "^1.2.1"
+ },
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/type-detect": {
+ "version": "4.0.8",
+ "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz",
+ "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=4"
+ }
+ },
+ "node_modules/type-fest": {
+ "version": "0.20.2",
+ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
+ "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
+ "dev": true,
+ "license": "(MIT OR CC0-1.0)",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/type-is": {
+ "version": "1.6.18",
+ "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+ "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+ "license": "MIT",
+ "dependencies": {
+ "media-typer": "0.3.0",
+ "mime-types": "~2.1.24"
+ },
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/typescript": {
+ "version": "5.9.2",
+ "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.2.tgz",
+ "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "bin": {
+ "tsc": "bin/tsc",
+ "tsserver": "bin/tsserver"
+ },
+ "engines": {
+ "node": ">=14.17"
+ }
+ },
+ "node_modules/uglify-js": {
+ "version": "3.19.3",
+ "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.19.3.tgz",
+ "integrity": "sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "optional": true,
+ "bin": {
+ "uglifyjs": "bin/uglifyjs"
+ },
+ "engines": {
+ "node": ">=0.8.0"
+ }
+ },
+ "node_modules/undici-types": {
+ "version": "6.21.0",
+ "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+ "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/unpipe": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+ "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/update-browserslist-db": {
+ "version": "1.1.3",
+ "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz",
+ "integrity": "sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/browserslist"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/funding/github/npm/browserslist"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "escalade": "^3.2.0",
+ "picocolors": "^1.1.1"
+ },
+ "bin": {
+ "update-browserslist-db": "cli.js"
+ },
+ "peerDependencies": {
+ "browserslist": ">= 4.21.0"
+ }
+ },
+ "node_modules/uri-js": {
+ "version": "4.4.1",
+ "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+ "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "punycode": "^2.1.0"
+ }
+ },
+ "node_modules/util-deprecate": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+ "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+ "license": "MIT"
+ },
+ "node_modules/utils-merge": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+ "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4.0"
+ }
+ },
+ "node_modules/v8-to-istanbul": {
+ "version": "9.3.0",
+ "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-9.3.0.tgz",
+ "integrity": "sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "@jridgewell/trace-mapping": "^0.3.12",
+ "@types/istanbul-lib-coverage": "^2.0.1",
+ "convert-source-map": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10.12.0"
+ }
+ },
+ "node_modules/vary": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+ "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/walker": {
+ "version": "1.0.8",
+ "resolved": "https://registry.npmjs.org/walker/-/walker-1.0.8.tgz",
+ "integrity": "sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "makeerror": "1.0.12"
+ }
+ },
+ "node_modules/which": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+ "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "isexe": "^2.0.0"
+ },
+ "bin": {
+ "node-which": "bin/node-which"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/winston": {
+ "version": "3.17.0",
+ "resolved": "https://registry.npmjs.org/winston/-/winston-3.17.0.tgz",
+ "integrity": "sha512-DLiFIXYC5fMPxaRg832S6F5mJYvePtmO5G9v9IgUFPhXm9/GkXarH/TUrBAVzhTCzAj9anE/+GjrgXp/54nOgw==",
+ "license": "MIT",
+ "dependencies": {
+ "@colors/colors": "^1.6.0",
+ "@dabh/diagnostics": "^2.0.2",
+ "async": "^3.2.3",
+ "is-stream": "^2.0.0",
+ "logform": "^2.7.0",
+ "one-time": "^1.0.0",
+ "readable-stream": "^3.4.0",
+ "safe-stable-stringify": "^2.3.1",
+ "stack-trace": "0.0.x",
+ "triple-beam": "^1.3.0",
+ "winston-transport": "^4.9.0"
+ },
+ "engines": {
+ "node": ">= 12.0.0"
+ }
+ },
+ "node_modules/winston-transport": {
+ "version": "4.9.0",
+ "resolved": "https://registry.npmjs.org/winston-transport/-/winston-transport-4.9.0.tgz",
+ "integrity": "sha512-8drMJ4rkgaPo1Me4zD/3WLfI/zPdA9o2IipKODunnGDcuqbHwjsbB79ylv04LCGGzU0xQ6vTznOMpQGaLhhm6A==",
+ "license": "MIT",
+ "dependencies": {
+ "logform": "^2.7.0",
+ "readable-stream": "^3.6.2",
+ "triple-beam": "^1.3.0"
+ },
+ "engines": {
+ "node": ">= 12.0.0"
+ }
+ },
+ "node_modules/winston-transport/node_modules/readable-stream": {
+ "version": "3.6.2",
+ "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+ "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+ "license": "MIT",
+ "dependencies": {
+ "inherits": "^2.0.3",
+ "string_decoder": "^1.1.1",
+ "util-deprecate": "^1.0.1"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/winston/node_modules/readable-stream": {
+ "version": "3.6.2",
+ "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+ "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+ "license": "MIT",
+ "dependencies": {
+ "inherits": "^2.0.3",
+ "string_decoder": "^1.1.1",
+ "util-deprecate": "^1.0.1"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/word-wrap": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+ "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/wordwrap": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz",
+ "integrity": "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/wrap-ansi": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+ "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-styles": "^4.0.0",
+ "string-width": "^4.1.0",
+ "strip-ansi": "^6.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+ }
+ },
+ "node_modules/wrappy": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+ "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+ "license": "ISC"
+ },
+ "node_modules/write-file-atomic": {
+ "version": "4.0.2",
+ "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-4.0.2.tgz",
+ "integrity": "sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "imurmurhash": "^0.1.4",
+ "signal-exit": "^3.0.7"
+ },
+ "engines": {
+ "node": "^12.13.0 || ^14.15.0 || >=16.0.0"
+ }
+ },
+ "node_modules/xmldoc": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/xmldoc/-/xmldoc-0.4.0.tgz",
+ "integrity": "sha512-rJ/+/UzYCSlFNuAzGuRyYgkH2G5agdX1UQn4+5siYw9pkNC3Hu/grYNDx/dqYLreeSjnY5oKg74CMBKxJHSg6Q==",
+ "license": "MIT",
+ "dependencies": {
+ "sax": "~1.1.1"
+ }
+ },
+ "node_modules/y18n": {
+ "version": "5.0.8",
+ "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+ "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/yallist": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+ "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/yamljs": {
+ "version": "0.3.0",
+ "resolved": "https://registry.npmjs.org/yamljs/-/yamljs-0.3.0.tgz",
+ "integrity": "sha512-C/FsVVhht4iPQYXOInoxUM/1ELSf9EsgKH34FofQOp6hwCPrW4vG4w5++TED3xRUo8gD7l0P1J1dLlDYzODsTQ==",
+ "license": "MIT",
+ "dependencies": {
+ "argparse": "^1.0.7",
+ "glob": "^7.0.5"
+ },
+ "bin": {
+ "json2yaml": "bin/json2yaml",
+ "yaml2json": "bin/yaml2json"
+ }
+ },
+ "node_modules/yamljs/node_modules/argparse": {
+ "version": "1.0.10",
+ "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+ "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+ "license": "MIT",
+ "dependencies": {
+ "sprintf-js": "~1.0.2"
+ }
+ },
+ "node_modules/yargs": {
+ "version": "17.7.2",
+ "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+ "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "cliui": "^8.0.1",
+ "escalade": "^3.1.1",
+ "get-caller-file": "^2.0.5",
+ "require-directory": "^2.1.1",
+ "string-width": "^4.2.3",
+ "y18n": "^5.0.5",
+ "yargs-parser": "^21.1.1"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/yargs-parser": {
+ "version": "21.1.1",
+ "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+ "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/yocto-queue": {
+ "version": "0.1.0",
+ "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+ "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/zod": {
+ "version": "3.25.76",
+ "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+ "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/colinhacks"
+ }
+ },
+ "packages/fmlrunner": {
+ "version": "0.1.0",
+ "license": "MIT",
+ "dependencies": {
+ "ajv": "^8.12.0",
+ "ajv-formats": "^2.1.1",
+ "fhirpath": "^4.6.0",
+ "winston": "^3.11.0"
+ },
+ "devDependencies": {
+ "ajv-cli": "^5.0.0"
+ },
+ "engines": {
+ "node": ">=16.0.0",
+ "npm": ">=8.0.0"
+ }
+ },
+ "packages/fmlrunner-mcp": {
+ "version": "0.1.0",
+ "license": "MIT",
+ "dependencies": {
+ "@modelcontextprotocol/sdk": "^0.5.0",
+ "ajv": "^8.12.0",
+ "ajv-formats": "^2.1.1",
+ "fmlrunner": "file:../fmlrunner",
+ "winston": "^3.11.0"
+ },
+ "bin": {
+ "fmlrunner-mcp": "dist/server.js"
+ },
+ "devDependencies": {},
+ "engines": {
+ "node": ">=16.0.0",
+ "npm": ">=8.0.0"
+ }
+ },
+ "packages/fmlrunner-mcp/node_modules/ajv": {
+ "version": "8.17.1",
+ "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
+ "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+ "license": "MIT",
+ "dependencies": {
+ "fast-deep-equal": "^3.1.3",
+ "fast-uri": "^3.0.1",
+ "json-schema-traverse": "^1.0.0",
+ "require-from-string": "^2.0.2"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/epoberezkin"
+ }
+ },
+ "packages/fmlrunner-mcp/node_modules/json-schema-traverse": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+ "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+ "license": "MIT"
+ },
+ "packages/fmlrunner-rest": {
+ "version": "0.1.0",
+ "license": "MIT",
+ "dependencies": {
+ "cors": "^2.8.5",
+ "express": "^4.18.0",
+ "fmlrunner": "file:../fmlrunner",
+ "swagger-ui-express": "^5.0.0",
+ "winston": "^3.11.0",
+ "yamljs": "^0.3.0"
+ },
+ "bin": {
+ "fmlrunner-rest": "dist/server.js"
+ },
+ "devDependencies": {
+ "@types/cors": "^2.8.0",
+ "@types/express": "^4.17.0",
+ "@types/supertest": "^6.0.0",
+ "@types/swagger-ui-express": "^4.1.0",
+ "supertest": "^6.3.0"
+ },
+ "engines": {
+ "node": ">=16.0.0",
+ "npm": ">=8.0.0"
+ }
+ },
+ "packages/fmlrunner-web": {
+ "version": "0.1.0",
+ "extraneous": true,
+ "license": "MIT",
+ "dependencies": {
+ "@reduxjs/toolkit": "^2.0.0",
+ "@types/react": "^18.2.0",
+ "@types/react-dom": "^18.2.0",
+ "fmlrunner": "file:../fmlrunner",
+ "react": "^18.2.0",
+ "react-dom": "^18.2.0",
+ "react-redux": "^9.0.0",
+ "swagger-ui-react": "^5.10.0"
+ },
+ "devDependencies": {
+ "@typescript-eslint/eslint-plugin": "^6.0.0",
+ "@typescript-eslint/parser": "^6.0.0",
+ "@vitejs/plugin-react": "^4.2.0",
+ "eslint": "^8.57.0",
+ "eslint-plugin-react-hooks": "^4.6.0",
+ "eslint-plugin-react-refresh": "^0.4.5",
+ "typescript": "^5.2.0",
+ "vite": "^5.0.0",
+ "vitest": "^1.0.0"
+ },
+ "engines": {
+ "node": ">=16.0.0",
+ "npm": ">=8.0.0"
+ }
+ },
+ "packages/fmlrunner/node_modules/ajv": {
+ "version": "8.17.1",
+ "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
+ "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+ "license": "MIT",
+ "dependencies": {
+ "fast-deep-equal": "^3.1.3",
+ "fast-uri": "^3.0.1",
+ "json-schema-traverse": "^1.0.0",
+ "require-from-string": "^2.0.2"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/epoberezkin"
+ }
+ },
+ "packages/fmlrunner/node_modules/json-schema-traverse": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+ "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+ "license": "MIT"
+ }
+ }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..b01288f
--- /dev/null
+++ b/package.json
@@ -0,0 +1,58 @@
+{
+ "name": "fmlrunner-monorepo",
+ "version": "0.1.0",
+ "description": "Monorepo for FML Runner packages: core library, MCP interface, REST API, and web interface",
+ "private": true,
+ "workspaces": [
+ "packages/fmlrunner",
+ "packages/fmlrunner-rest",
+ "packages/fmlrunner-mcp"
+ ],
+ "scripts": {
+ "build": "npm run build --workspaces --if-present",
+ "test": "npm run test --workspaces --if-present",
+ "lint": "npm run lint --workspaces --if-present",
+ "clean": "npm run clean --workspaces --if-present",
+ "dev": "concurrently \"npm run dev --workspace=packages/fmlrunner-rest\"",
+ "build:web": "echo 'Web package removed to reduce dependencies'",
+ "deploy:web": "echo 'Web package removed to reduce dependencies'",
+ "version:patch": "node scripts/version.js bump patch",
+ "version:minor": "node scripts/version.js bump minor",
+ "version:major": "node scripts/version.js bump major",
+ "version:set": "node scripts/version.js set",
+ "version:current": "node scripts/version.js current",
+ "publish:all": "npm run build && node scripts/version.js publish",
+ "publish:dry-run": "npm run build && node scripts/version.js publish --dry-run",
+ "prepare:publish": "node scripts/version.js prepare-publish",
+ "restore:dev": "node scripts/version.js restore-dev",
+ "prerelease": "npm run lint && npm run test && npm run build",
+ "release": "npm run prerelease && npm run publish:all",
+ "tag": "node scripts/version.js tag"
+ },
+ "devDependencies": {
+ "@types/jest": "^29.0.0",
+ "@types/node": "^20.0.0",
+ "@typescript-eslint/eslint-plugin": "^6.0.0",
+ "@typescript-eslint/parser": "^6.0.0",
+ "eslint": "^8.0.0",
+ "jest": "^29.0.0",
+ "ts-jest": "^29.0.0",
+ "typescript": "^5.0.0",
+ "gh-pages": "^6.1.0",
+ "concurrently": "^8.2.0"
+ },
+ "engines": {
+ "node": ">=16.0.0",
+ "npm": ">=8.0.0"
+ },
+ "author": "Carl Leitner",
+ "license": "MIT",
+ "homepage": "https://github.com/litlfred/fmlrunner#readme",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/litlfred/fmlrunner.git"
+ },
+ "bugs": {
+ "url": "https://github.com/litlfred/fmlrunner/issues"
+ }
+}
diff --git a/packages/fmlrunner-mcp/.npmignore b/packages/fmlrunner-mcp/.npmignore
new file mode 100644
index 0000000..2a6ebf0
--- /dev/null
+++ b/packages/fmlrunner-mcp/.npmignore
@@ -0,0 +1,103 @@
+# Development files
+src/
+tests/
+*.test.ts
+*.spec.ts
+.eslintrc.*
+jest.config.*
+tsconfig.json
+
+# Build artifacts
+*.tsbuildinfo
+coverage/
+.nyc_output/
+
+# IDE and editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids/
+*.pid
+*.seed
+*.pid.lock
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+.env.test
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# next.js build output
+.next
+
+# nuxt.js build output
+.nuxt
+
+# gatsby files
+.cache/
+public
+
+# vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
\ No newline at end of file
diff --git a/packages/fmlrunner-mcp/jest.config.js b/packages/fmlrunner-mcp/jest.config.js
new file mode 100644
index 0000000..0be3fa7
--- /dev/null
+++ b/packages/fmlrunner-mcp/jest.config.js
@@ -0,0 +1,10 @@
+module.exports = {
+ preset: 'ts-jest',
+ testEnvironment: 'node',
+ roots: ['/tests'],
+ testMatch: ['**/*.test.ts'],
+ collectCoverageFrom: [
+ 'src/**/*.ts',
+ '!src/**/*.d.ts',
+ ]
+};
\ No newline at end of file
diff --git a/packages/fmlrunner-mcp/package.json b/packages/fmlrunner-mcp/package.json
new file mode 100644
index 0000000..56ff05c
--- /dev/null
+++ b/packages/fmlrunner-mcp/package.json
@@ -0,0 +1,63 @@
+{
+ "name": "fmlrunner-mcp",
+ "version": "0.1.0",
+ "description": "Model Context Protocol (MCP) interface for FML Runner providing AI-compatible tools for FHIR mapping and transformation with JSON schema validation",
+ "keywords": [
+ "fhir",
+ "fml",
+ "mcp",
+ "model-context-protocol",
+ "jsonschema",
+ "ai",
+ "claude",
+ "anthropic",
+ "tools"
+ ],
+ "publishConfig": {
+ "access": "public",
+ "registry": "https://registry.npmjs.org/"
+ },
+ "author": "Carl Leitner",
+ "license": "MIT",
+ "homepage": "https://github.com/litlfred/fmlrunner#readme",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/litlfred/fmlrunner.git"
+ },
+ "bugs": {
+ "url": "https://github.com/litlfred/fmlrunner/issues"
+ },
+ "engines": {
+ "node": ">=16.0.0",
+ "npm": ">=8.0.0"
+ },
+ "main": "dist/index.js",
+ "types": "dist/index.d.ts",
+ "bin": {
+ "fmlrunner-mcp": "dist/server.js"
+ },
+ "files": [
+ "dist/",
+ "schemas/",
+ "README.md",
+ "LICENSE"
+ ],
+ "scripts": {
+ "build": "tsc",
+ "test": "jest",
+ "lint": "eslint src/**/*.ts",
+ "clean": "rm -rf dist",
+ "start": "node dist/server.js",
+ "dev": "tsc && node dist/server.js",
+ "prepublishOnly": "npm run clean && npm run build && npm run test"
+ },
+ "devDependencies": {
+ },
+ "dependencies": {
+ "@modelcontextprotocol/sdk": "^0.5.0",
+ "ajv": "^8.12.0",
+ "ajv-formats": "^2.1.1",
+ "fmlrunner": "file:../fmlrunner",
+ "winston": "^3.11.0"
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner-mcp/src/index.ts b/packages/fmlrunner-mcp/src/index.ts
new file mode 100644
index 0000000..6d676e1
--- /dev/null
+++ b/packages/fmlrunner-mcp/src/index.ts
@@ -0,0 +1,625 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+ CallToolRequestSchema,
+ ListToolsRequestSchema,
+ Tool,
+ CallToolRequest,
+ CallToolResult,
+ TextContent,
+ ImageContent,
+ EmbeddedResource
+} from '@modelcontextprotocol/sdk/types.js';
+import { FmlRunner } from 'fmlrunner';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import winston from 'winston';
+
+/**
+ * MCP interface for FML Runner with JSON schema-defined endpoints
+ */
+export class FmlRunnerMcp {
+ private server: Server;
+ private fmlRunner: FmlRunner;
+ private ajv: Ajv;
+ private logger: winston.Logger;
+
+ constructor(options?: { logLevel?: string; baseUrl?: string }) {
+ this.logger = winston.createLogger({
+ level: options?.logLevel || 'info',
+ format: winston.format.combine(
+ winston.format.timestamp(),
+ winston.format.errors({ stack: true }),
+ winston.format.json()
+ ),
+ transports: [
+ new winston.transports.Console({
+ format: winston.format.combine(
+ winston.format.colorize(),
+ winston.format.simple()
+ )
+ })
+ ]
+ });
+
+ this.fmlRunner = new FmlRunner({
+ baseUrl: options?.baseUrl,
+ logLevel: options?.logLevel as any,
+ validateInputOutput: true
+ });
+
+ this.ajv = new Ajv({ allErrors: true, verbose: true });
+ addFormats(this.ajv);
+
+ this.server = new Server(
+ {
+ name: 'fmlrunner-mcp',
+ version: '0.1.0',
+ description: 'FHIR Mapping Language (FML) Runner MCP interface for compiling and executing StructureMaps'
+ },
+ {
+ capabilities: {
+ tools: {}
+ }
+ }
+ );
+
+ this.setupSchemas();
+ this.setupTools();
+ }
+
+ private setupSchemas(): void {
+ // FML Compilation Input Schema
+ const fmlCompilationInputSchema = {
+ type: 'object',
+ properties: {
+ fmlContent: {
+ type: 'string',
+ minLength: 1,
+ pattern: '^map\\s+',
+ description: 'FHIR Mapping Language (FML) content starting with map declaration'
+ }
+ },
+ required: ['fmlContent'],
+ additionalProperties: false
+ };
+ this.ajv.addSchema(fmlCompilationInputSchema, 'fml-compilation-input');
+
+ // StructureMap Execution Input Schema
+ const structureMapExecutionInputSchema = {
+ type: 'object',
+ properties: {
+ structureMapReference: {
+ type: 'string',
+ minLength: 1,
+ description: 'Reference to StructureMap (ID or URL)'
+ },
+ inputContent: {
+ description: 'Input data to transform (any valid JSON)',
+ oneOf: [
+ { type: 'object' },
+ { type: 'array' },
+ { type: 'string' },
+ { type: 'number' },
+ { type: 'boolean' }
+ ]
+ },
+ options: {
+ type: 'object',
+ properties: {
+ strictMode: {
+ type: 'boolean',
+ description: 'Enable strict validation mode'
+ },
+ validateInputOutput: {
+ type: 'boolean',
+ description: 'Enable input/output validation'
+ }
+ },
+ additionalProperties: false
+ }
+ },
+ required: ['structureMapReference', 'inputContent'],
+ additionalProperties: false
+ };
+ this.ajv.addSchema(structureMapExecutionInputSchema, 'structuremap-execution-input');
+
+ // Bundle Processing Input Schema
+ const bundleProcessingInputSchema = {
+ type: 'object',
+ properties: {
+ bundle: {
+ type: 'object',
+ properties: {
+ resourceType: { type: 'string', const: 'Bundle' },
+ entry: {
+ type: 'array',
+ items: {
+ type: 'object',
+ properties: {
+ resource: { type: 'object' }
+ },
+ required: ['resource']
+ }
+ }
+ },
+ required: ['resourceType'],
+ additionalProperties: true
+ }
+ },
+ required: ['bundle'],
+ additionalProperties: false
+ };
+ this.ajv.addSchema(bundleProcessingInputSchema, 'bundle-processing-input');
+
+ // Resource Management Input Schema
+ const resourceManagementInputSchema = {
+ type: 'object',
+ properties: {
+ resource: {
+ type: 'object',
+ description: 'FHIR resource (StructureMap, ConceptMap, ValueSet, CodeSystem, StructureDefinition)'
+ },
+ resourceType: {
+ type: 'string',
+ enum: ['StructureMap', 'ConceptMap', 'ValueSet', 'CodeSystem', 'StructureDefinition'],
+ description: 'Type of FHIR resource'
+ },
+ reference: {
+ type: 'string',
+ description: 'Resource reference (ID or URL) for retrieval/deletion operations'
+ }
+ },
+ additionalProperties: false
+ };
+ this.ajv.addSchema(resourceManagementInputSchema, 'resource-management-input');
+ }
+
+ private setupTools(): void {
+ // FML Compilation Tool
+ this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+ return {
+ tools: [
+ {
+ name: 'compile-fml',
+ description: 'Compile FHIR Mapping Language (FML) content into a StructureMap resource',
+ inputSchema: {
+ type: 'object',
+ properties: {
+ fmlContent: {
+ type: 'string',
+ description: 'FML content to compile (must start with map declaration)'
+ }
+ },
+ required: ['fmlContent']
+ }
+ },
+ {
+ name: 'execute-structuremap',
+ description: 'Execute a StructureMap transformation on input data',
+ inputSchema: {
+ type: 'object',
+ properties: {
+ structureMapReference: {
+ type: 'string',
+ description: 'StructureMap reference (ID or URL)'
+ },
+ inputContent: {
+ description: 'Input data to transform'
+ },
+ options: {
+ type: 'object',
+ properties: {
+ strictMode: { type: 'boolean' },
+ validateInputOutput: { type: 'boolean' }
+ }
+ }
+ },
+ required: ['structureMapReference', 'inputContent']
+ }
+ },
+ {
+ name: 'process-bundle',
+ description: 'Process a FHIR Bundle containing multiple resources (StructureMaps, ConceptMaps, etc.)',
+ inputSchema: {
+ type: 'object',
+ properties: {
+ bundle: {
+ type: 'object',
+ description: 'FHIR Bundle resource with entries'
+ }
+ },
+ required: ['bundle']
+ }
+ },
+ {
+ name: 'register-resource',
+ description: 'Register a FHIR resource (StructureMap, ConceptMap, ValueSet, CodeSystem, StructureDefinition)',
+ inputSchema: {
+ type: 'object',
+ properties: {
+ resource: {
+ type: 'object',
+ description: 'FHIR resource to register'
+ },
+ resourceType: {
+ type: 'string',
+ enum: ['StructureMap', 'ConceptMap', 'ValueSet', 'CodeSystem', 'StructureDefinition']
+ }
+ },
+ required: ['resource', 'resourceType']
+ }
+ },
+ {
+ name: 'get-resource',
+ description: 'Retrieve a registered FHIR resource by reference',
+ inputSchema: {
+ type: 'object',
+ properties: {
+ reference: {
+ type: 'string',
+ description: 'Resource reference (ID or URL)'
+ },
+ resourceType: {
+ type: 'string',
+ enum: ['StructureMap', 'ConceptMap', 'ValueSet', 'CodeSystem', 'StructureDefinition']
+ }
+ },
+ required: ['reference', 'resourceType']
+ }
+ },
+ {
+ name: 'list-resources',
+ description: 'List all registered resources of a specific type',
+ inputSchema: {
+ type: 'object',
+ properties: {
+ resourceType: {
+ type: 'string',
+ enum: ['StructureMap', 'ConceptMap', 'ValueSet', 'CodeSystem', 'StructureDefinition']
+ },
+ searchParams: {
+ type: 'object',
+ description: 'Optional search parameters (name, status, url, etc.)'
+ }
+ },
+ required: ['resourceType']
+ }
+ },
+ {
+ name: 'translate-code',
+ description: 'Translate a code using registered ConceptMaps',
+ inputSchema: {
+ type: 'object',
+ properties: {
+ sourceSystem: { type: 'string' },
+ sourceCode: { type: 'string' },
+ targetSystem: { type: 'string' }
+ },
+ required: ['sourceSystem', 'sourceCode']
+ }
+ },
+ {
+ name: 'validate-code',
+ description: 'Validate a code against a ValueSet or CodeSystem',
+ inputSchema: {
+ type: 'object',
+ properties: {
+ valueSetRef: { type: 'string' },
+ system: { type: 'string' },
+ code: { type: 'string' },
+ display: { type: 'string' }
+ },
+ required: ['valueSetRef', 'code']
+ }
+ }
+ ]
+ };
+ });
+
+ // Tool Call Handler
+ this.server.setRequestHandler(CallToolRequestSchema, async (request: CallToolRequest): Promise => {
+ const { name, arguments: args } = request.params;
+
+ try {
+ this.logger.info(`Executing MCP tool: ${name}`, { args });
+
+ switch (name) {
+ case 'compile-fml':
+ return await this.handleCompileFml(args);
+
+ case 'execute-structuremap':
+ return await this.handleExecuteStructureMap(args);
+
+ case 'process-bundle':
+ return await this.handleProcessBundle(args);
+
+ case 'register-resource':
+ return await this.handleRegisterResource(args);
+
+ case 'get-resource':
+ return await this.handleGetResource(args);
+
+ case 'list-resources':
+ return await this.handleListResources(args);
+
+ case 'translate-code':
+ return await this.handleTranslateCode(args);
+
+ case 'validate-code':
+ return await this.handleValidateCode(args);
+
+ default:
+ throw new Error(`Unknown tool: ${name}`);
+ }
+ } catch (error) {
+ this.logger.error(`MCP tool execution failed: ${name}`, { error: error instanceof Error ? error.message : error });
+ return {
+ content: [
+ {
+ type: 'text',
+ text: `Error executing tool ${name}: ${error instanceof Error ? error.message : 'Unknown error'}`
+ }
+ ],
+ isError: true
+ };
+ }
+ });
+ }
+
+ private async handleCompileFml(args: any): Promise {
+ // Validate input
+ const validate = this.ajv.getSchema('fml-compilation-input');
+ if (!validate || !validate(args)) {
+ throw new Error(`Invalid input: ${validate?.errors?.map(e => e.message).join(', ')}`);
+ }
+
+ const result = this.fmlRunner.compileFml(args.fmlContent);
+
+ return {
+ content: [
+ {
+ type: 'text',
+ text: JSON.stringify({
+ success: result.success,
+ structureMap: result.structureMap,
+ errors: result.errors
+ }, null, 2)
+ }
+ ]
+ };
+ }
+
+ private async handleExecuteStructureMap(args: any): Promise {
+ // Validate input
+ const validate = this.ajv.getSchema('structuremap-execution-input');
+ if (!validate || !validate(args)) {
+ throw new Error(`Invalid input: ${validate?.errors?.map(e => e.message).join(', ')}`);
+ }
+
+ const result = await this.fmlRunner.executeStructureMapWithValidation(
+ args.structureMapReference,
+ args.inputContent,
+ args.options
+ );
+
+ return {
+ content: [
+ {
+ type: 'text',
+ text: JSON.stringify({
+ success: result.success,
+ output: result.result,
+ errors: result.errors,
+ warnings: result.errors || []
+ }, null, 2)
+ }
+ ]
+ };
+ }
+
+ private async handleProcessBundle(args: any): Promise {
+ // Validate input
+ const validate = this.ajv.getSchema('bundle-processing-input');
+ if (!validate || !validate(args)) {
+ throw new Error(`Invalid input: ${validate?.errors?.map(e => e.message).join(', ')}`);
+ }
+
+ const result = this.fmlRunner.processBundle(args.bundle);
+
+ return {
+ content: [
+ {
+ type: 'text',
+ text: JSON.stringify(result, null, 2)
+ }
+ ]
+ };
+ }
+
+ private async handleRegisterResource(args: any): Promise {
+ const { resource, resourceType } = args;
+
+ switch (resourceType) {
+ case 'StructureMap':
+ this.fmlRunner.registerStructureMap(resource);
+ break;
+ case 'ConceptMap':
+ this.fmlRunner.registerConceptMap(resource);
+ break;
+ case 'ValueSet':
+ this.fmlRunner.registerValueSet(resource);
+ break;
+ case 'CodeSystem':
+ this.fmlRunner.registerCodeSystem(resource);
+ break;
+ case 'StructureDefinition':
+ this.fmlRunner.registerStructureDefinition(resource);
+ break;
+ default:
+ throw new Error(`Unsupported resource type: ${resourceType}`);
+ }
+
+ return {
+ content: [
+ {
+ type: 'text',
+ text: JSON.stringify({
+ success: true,
+ message: `${resourceType} registered successfully`,
+ resourceId: resource.id
+ }, null, 2)
+ }
+ ]
+ };
+ }
+
+ private async handleGetResource(args: any): Promise {
+ const { reference, resourceType } = args;
+ let resource;
+
+ switch (resourceType) {
+ case 'StructureMap':
+ resource = await this.fmlRunner.getStructureMap(reference);
+ break;
+ case 'ConceptMap':
+ resource = this.fmlRunner.getConceptMap(reference);
+ break;
+ case 'ValueSet':
+ resource = this.fmlRunner.getValueSet(reference);
+ break;
+ case 'CodeSystem':
+ resource = this.fmlRunner.getCodeSystem(reference);
+ break;
+ default:
+ throw new Error(`Unsupported resource type: ${resourceType}`);
+ }
+
+ return {
+ content: [
+ {
+ type: 'text',
+ text: JSON.stringify({
+ found: !!resource,
+ resource: resource || null
+ }, null, 2)
+ }
+ ]
+ };
+ }
+
+ private async handleListResources(args: any): Promise {
+ const { resourceType, searchParams = {} } = args;
+ let resources;
+
+ switch (resourceType) {
+ case 'StructureMap':
+ resources = this.fmlRunner.searchStructureMaps(searchParams);
+ break;
+ case 'ConceptMap':
+ resources = this.fmlRunner.searchConceptMaps(searchParams);
+ break;
+ case 'ValueSet':
+ resources = this.fmlRunner.searchValueSets(searchParams);
+ break;
+ case 'CodeSystem':
+ resources = this.fmlRunner.searchCodeSystems(searchParams);
+ break;
+ default:
+ throw new Error(`Unsupported resource type: ${resourceType}`);
+ }
+
+ return {
+ content: [
+ {
+ type: 'text',
+ text: JSON.stringify({
+ resourceType,
+ count: resources.length,
+ resources
+ }, null, 2)
+ }
+ ]
+ };
+ }
+
+ private async handleTranslateCode(args: any): Promise {
+ const { sourceSystem, sourceCode, targetSystem } = args;
+
+ const translations = this.fmlRunner.translateCode(sourceSystem, sourceCode, targetSystem);
+
+ return {
+ content: [
+ {
+ type: 'text',
+ text: JSON.stringify({
+ sourceSystem,
+ sourceCode,
+ targetSystem,
+ translations
+ }, null, 2)
+ }
+ ]
+ };
+ }
+
+ private async handleValidateCode(args: any): Promise {
+ const { valueSetRef, system, code, display } = args;
+
+ const result = this.fmlRunner.validateCodeInValueSet(valueSetRef, system, code, display);
+
+ return {
+ content: [
+ {
+ type: 'text',
+ text: JSON.stringify({
+ valueSetRef,
+ system,
+ code,
+ display,
+ result: result.result,
+ message: result.message
+ }, null, 2)
+ }
+ ]
+ };
+ }
+
+ /**
+ * Start the MCP server
+ */
+ async start(): Promise {
+ const transport = new StdioServerTransport();
+ await this.server.connect(transport);
+ this.logger.info('FML Runner MCP server started');
+ }
+
+ /**
+ * Stop the MCP server
+ */
+ async stop(): Promise {
+ await this.server.close();
+ this.logger.info('FML Runner MCP server stopped');
+ }
+}
+
+// Export for use as a library
+// Class is already exported above
+
+// CLI entry point
+if (require.main === module) {
+ const mcp = new FmlRunnerMcp({
+ logLevel: process.env.LOG_LEVEL || 'info',
+ baseUrl: process.env.BASE_URL || './maps'
+ });
+
+ mcp.start().catch(error => {
+ console.error('Failed to start MCP server:', error);
+ process.exit(1);
+ });
+
+ process.on('SIGINT', async () => {
+ await mcp.stop();
+ process.exit(0);
+ });
+}
\ No newline at end of file
diff --git a/packages/fmlrunner-mcp/src/server.ts b/packages/fmlrunner-mcp/src/server.ts
new file mode 100644
index 0000000..e4dd6e7
--- /dev/null
+++ b/packages/fmlrunner-mcp/src/server.ts
@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+import { FmlRunnerMcp } from './index';
+
+const mcp = new FmlRunnerMcp({
+ logLevel: process.env.LOG_LEVEL || 'info',
+ baseUrl: process.env.BASE_URL || './maps'
+});
+
+mcp.start().catch(error => {
+ console.error('Failed to start FML Runner MCP server:', error);
+ process.exit(1);
+});
+
+process.on('SIGINT', async () => {
+ console.log('\nShutting down FML Runner MCP server...');
+ await mcp.stop();
+ process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+ console.log('\nShutting down FML Runner MCP server...');
+ await mcp.stop();
+ process.exit(0);
+});
\ No newline at end of file
diff --git a/packages/fmlrunner-mcp/tests/mcp.test.ts b/packages/fmlrunner-mcp/tests/mcp.test.ts
new file mode 100644
index 0000000..cd79ac8
--- /dev/null
+++ b/packages/fmlrunner-mcp/tests/mcp.test.ts
@@ -0,0 +1,5 @@
+describe('FML Runner MCP Interface', () => {
+ test('should create MCP instance', () => {
+ expect(true).toBe(true);
+ });
+});
\ No newline at end of file
diff --git a/packages/fmlrunner-mcp/tsconfig.json b/packages/fmlrunner-mcp/tsconfig.json
new file mode 100644
index 0000000..aba4d5c
--- /dev/null
+++ b/packages/fmlrunner-mcp/tsconfig.json
@@ -0,0 +1,18 @@
+{
+ "compilerOptions": {
+ "target": "ES2020",
+ "module": "commonjs",
+ "lib": ["ES2020"],
+ "outDir": "./dist",
+ "rootDir": "./src",
+ "strict": true,
+ "esModuleInterop": true,
+ "skipLibCheck": true,
+ "forceConsistentCasingInFileNames": true,
+ "declaration": true,
+ "declarationMap": true,
+ "sourceMap": true
+ },
+ "include": ["src/**/*"],
+ "exclude": ["node_modules", "dist", "tests"]
+}
\ No newline at end of file
diff --git a/packages/fmlrunner-rest/.npmignore b/packages/fmlrunner-rest/.npmignore
new file mode 100644
index 0000000..2a6ebf0
--- /dev/null
+++ b/packages/fmlrunner-rest/.npmignore
@@ -0,0 +1,103 @@
+# Development files
+src/
+tests/
+*.test.ts
+*.spec.ts
+.eslintrc.*
+jest.config.*
+tsconfig.json
+
+# Build artifacts
+*.tsbuildinfo
+coverage/
+.nyc_output/
+
+# IDE and editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids/
+*.pid
+*.seed
+*.pid.lock
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+.env.test
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# next.js build output
+.next
+
+# nuxt.js build output
+.nuxt
+
+# gatsby files
+.cache/
+public
+
+# vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
\ No newline at end of file
diff --git a/packages/fmlrunner-rest/jest.config.js b/packages/fmlrunner-rest/jest.config.js
new file mode 100644
index 0000000..0be3fa7
--- /dev/null
+++ b/packages/fmlrunner-rest/jest.config.js
@@ -0,0 +1,10 @@
+module.exports = {
+ preset: 'ts-jest',
+ testEnvironment: 'node',
+ roots: ['/tests'],
+ testMatch: ['**/*.test.ts'],
+ collectCoverageFrom: [
+ 'src/**/*.ts',
+ '!src/**/*.d.ts',
+ ]
+};
\ No newline at end of file
diff --git a/packages/fmlrunner-rest/openapi.yaml b/packages/fmlrunner-rest/openapi.yaml
new file mode 100644
index 0000000..b038b48
--- /dev/null
+++ b/packages/fmlrunner-rest/openapi.yaml
@@ -0,0 +1,520 @@
+openapi: 3.0.3
+info:
+ title: FML Runner REST API
+ description: |
+ REST API for FHIR Mapping Language (FML) Runner providing FHIR-compliant endpoints
+ for StructureMap compilation, execution, and resource management.
+ version: 0.1.0
+ contact:
+ name: Carl Leitner
+ url: https://github.com/litlfred/fmlrunner
+ license:
+ name: MIT
+ url: https://opensource.org/licenses/MIT
+
+servers:
+ - url: http://localhost:3000
+ description: Development server
+
+paths:
+ /health:
+ get:
+ summary: Health check endpoint
+ description: Returns the health status of the FML Runner service
+ tags:
+ - Health
+ responses:
+ '200':
+ description: Service is healthy
+ content:
+ application/json:
+ schema:
+ type: object
+ properties:
+ status:
+ type: string
+ example: ok
+ timestamp:
+ type: string
+ format: date-time
+ version:
+ type: string
+ example: 0.1.0
+
+ /StructureMap:
+ get:
+ summary: List StructureMaps
+ description: Retrieve all registered StructureMaps with optional filtering
+ tags:
+ - StructureMap
+ parameters:
+ - name: name
+ in: query
+ description: Filter by StructureMap name
+ schema:
+ type: string
+ - name: status
+ in: query
+ description: Filter by StructureMap status
+ schema:
+ type: string
+ enum: [draft, active, retired, unknown]
+ - name: url
+ in: query
+ description: Filter by StructureMap URL
+ schema:
+ type: string
+ format: uri
+ - name: _count
+ in: query
+ description: Number of results to return
+ schema:
+ type: integer
+ minimum: 1
+ maximum: 100
+ default: 20
+ - name: _offset
+ in: query
+ description: Number of results to skip
+ schema:
+ type: integer
+ minimum: 0
+ default: 0
+ responses:
+ '200':
+ description: List of StructureMaps
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureMapBundle'
+
+ post:
+ summary: Create StructureMap
+ description: Create a new StructureMap (server assigns ID)
+ tags:
+ - StructureMap
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ oneOf:
+ - $ref: '#/components/schemas/StructureMap'
+ - $ref: '#/components/schemas/FmlContent'
+ responses:
+ '201':
+ description: StructureMap created successfully
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureMap'
+ '400':
+ description: Invalid input
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ /StructureMap/{id}:
+ get:
+ summary: Get StructureMap by ID
+ description: Retrieve a specific StructureMap by ID
+ tags:
+ - StructureMap
+ parameters:
+ - name: id
+ in: path
+ required: true
+ description: StructureMap ID
+ schema:
+ type: string
+ responses:
+ '200':
+ description: StructureMap found
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureMap'
+ '404':
+ description: StructureMap not found
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ put:
+ summary: Update StructureMap
+ description: Create or update a StructureMap with specific ID
+ tags:
+ - StructureMap
+ parameters:
+ - name: id
+ in: path
+ required: true
+ description: StructureMap ID
+ schema:
+ type: string
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ oneOf:
+ - $ref: '#/components/schemas/StructureMap'
+ - $ref: '#/components/schemas/FmlContent'
+ responses:
+ '200':
+ description: StructureMap updated successfully
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureMap'
+ '201':
+ description: StructureMap created successfully
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/StructureMap'
+ '400':
+ description: Invalid input
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ delete:
+ summary: Delete StructureMap
+ description: Remove a StructureMap by ID
+ tags:
+ - StructureMap
+ parameters:
+ - name: id
+ in: path
+ required: true
+ description: StructureMap ID
+ schema:
+ type: string
+ responses:
+ '204':
+ description: StructureMap deleted successfully
+ '404':
+ description: StructureMap not found
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ /StructureMap/$transform:
+ post:
+ summary: Transform operation
+ description: Execute StructureMap transformation on input data
+ tags:
+ - StructureMap Operations
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/TransformParameters'
+ responses:
+ '200':
+ description: Transformation completed successfully
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/TransformResult'
+ '400':
+ description: Invalid input or transformation error
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+ /Bundle:
+ post:
+ summary: Upload FHIR Bundle
+ description: Process a FHIR Bundle containing StructureMaps, ConceptMaps, ValueSets, CodeSystems, and StructureDefinitions
+ tags:
+ - Bundle
+ requestBody:
+ required: true
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Bundle'
+ responses:
+ '200':
+ description: Bundle processed successfully
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/BundleProcessingResult'
+ '400':
+ description: Invalid Bundle
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/OperationOutcome'
+
+components:
+ schemas:
+ StructureMap:
+ type: object
+ properties:
+ resourceType:
+ type: string
+ const: StructureMap
+ id:
+ type: string
+ url:
+ type: string
+ format: uri
+ name:
+ type: string
+ title:
+ type: string
+ status:
+ type: string
+ enum: [draft, active, retired, unknown]
+ experimental:
+ type: boolean
+ description:
+ type: string
+ group:
+ type: array
+ items:
+ $ref: '#/components/schemas/StructureMapGroup'
+ required:
+ - resourceType
+ - group
+
+ StructureMapGroup:
+ type: object
+ properties:
+ name:
+ type: string
+ typeMode:
+ type: string
+ enum: [none, types, type-and-types]
+ documentation:
+ type: string
+ input:
+ type: array
+ items:
+ $ref: '#/components/schemas/StructureMapGroupInput'
+ rule:
+ type: array
+ items:
+ $ref: '#/components/schemas/StructureMapGroupRule'
+ required:
+ - name
+ - input
+
+ StructureMapGroupInput:
+ type: object
+ properties:
+ name:
+ type: string
+ type:
+ type: string
+ mode:
+ type: string
+ enum: [source, target]
+ documentation:
+ type: string
+ required:
+ - name
+ - mode
+
+ StructureMapGroupRule:
+ type: object
+ properties:
+ name:
+ type: string
+ source:
+ type: array
+ items:
+ $ref: '#/components/schemas/StructureMapGroupRuleSource'
+ target:
+ type: array
+ items:
+ $ref: '#/components/schemas/StructureMapGroupRuleTarget'
+ documentation:
+ type: string
+ required:
+ - source
+
+ StructureMapGroupRuleSource:
+ type: object
+ properties:
+ context:
+ type: string
+ element:
+ type: string
+ variable:
+ type: string
+ type:
+ type: string
+ min:
+ type: integer
+ minimum: 0
+ max:
+ type: string
+ required:
+ - context
+
+ StructureMapGroupRuleTarget:
+ type: object
+ properties:
+ context:
+ type: string
+ contextType:
+ type: string
+ enum: [variable, type]
+
+ FmlContent:
+ type: object
+ properties:
+ contentType:
+ type: string
+ const: text/fml
+ content:
+ type: string
+ description: FML source content
+ required:
+ - contentType
+ - content
+
+ TransformParameters:
+ type: object
+ properties:
+ resourceType:
+ type: string
+ const: Parameters
+ parameter:
+ type: array
+ items:
+ type: object
+ properties:
+ name:
+ type: string
+ enum: [source, map]
+ valueString:
+ type: string
+ resource:
+ type: object
+ required:
+ - resourceType
+ - parameter
+
+ TransformResult:
+ type: object
+ properties:
+ resourceType:
+ type: string
+ const: Parameters
+ parameter:
+ type: array
+ items:
+ type: object
+ properties:
+ name:
+ type: string
+ const: result
+ resource:
+ type: object
+
+ Bundle:
+ type: object
+ properties:
+ resourceType:
+ type: string
+ const: Bundle
+ id:
+ type: string
+ type:
+ type: string
+ enum: [transaction, collection]
+ entry:
+ type: array
+ items:
+ type: object
+ properties:
+ resource:
+ type: object
+ required:
+ - resourceType
+
+ StructureMapBundle:
+ allOf:
+ - $ref: '#/components/schemas/Bundle'
+ - type: object
+ properties:
+ entry:
+ type: array
+ items:
+ type: object
+ properties:
+ resource:
+ $ref: '#/components/schemas/StructureMap'
+
+ BundleProcessingResult:
+ type: object
+ properties:
+ success:
+ type: boolean
+ processed:
+ type: integer
+ skipped:
+ type: integer
+ errors:
+ type: array
+ items:
+ type: string
+ resources:
+ type: object
+ properties:
+ structureMaps:
+ type: integer
+ structureDefinitions:
+ type: integer
+ conceptMaps:
+ type: integer
+ valueSets:
+ type: integer
+ codeSystems:
+ type: integer
+
+ OperationOutcome:
+ type: object
+ properties:
+ resourceType:
+ type: string
+ const: OperationOutcome
+ issue:
+ type: array
+ items:
+ type: object
+ properties:
+ severity:
+ type: string
+ enum: [fatal, error, warning, information]
+ code:
+ type: string
+ details:
+ type: object
+ properties:
+ text:
+ type: string
+ diagnostics:
+ type: string
+
+tags:
+ - name: Health
+ description: Health and status endpoints
+ - name: StructureMap
+ description: FHIR StructureMap resource management
+ - name: StructureMap Operations
+ description: FHIR StructureMap operations
+ - name: Bundle
+ description: FHIR Bundle processing
\ No newline at end of file
diff --git a/packages/fmlrunner-rest/package.json b/packages/fmlrunner-rest/package.json
new file mode 100644
index 0000000..78f7616
--- /dev/null
+++ b/packages/fmlrunner-rest/package.json
@@ -0,0 +1,69 @@
+{
+ "name": "fmlrunner-rest",
+ "version": "0.1.0",
+ "description": "REST API server for FML Runner with FHIR-compliant endpoints, CRUD operations for StructureMaps, ConceptMaps, ValueSets, and Bundle processing",
+ "keywords": [
+ "fhir",
+ "fml",
+ "rest",
+ "api",
+ "server",
+ "structuremap",
+ "openapi",
+ "express",
+ "crud",
+ "bundle"
+ ],
+ "publishConfig": {
+ "access": "public",
+ "registry": "https://registry.npmjs.org/"
+ },
+ "author": "Carl Leitner",
+ "license": "MIT",
+ "homepage": "https://github.com/litlfred/fmlrunner#readme",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/litlfred/fmlrunner.git"
+ },
+ "bugs": {
+ "url": "https://github.com/litlfred/fmlrunner/issues"
+ },
+ "engines": {
+ "node": ">=16.0.0",
+ "npm": ">=8.0.0"
+ },
+ "main": "dist/server.js",
+ "bin": {
+ "fmlrunner-rest": "dist/server.js"
+ },
+ "files": [
+ "dist/",
+ "openapi.yaml",
+ "README.md",
+ "LICENSE"
+ ],
+ "scripts": {
+ "build": "tsc",
+ "test": "jest",
+ "lint": "eslint src/**/*.ts",
+ "clean": "rm -rf dist",
+ "start": "node dist/server.js",
+ "dev": "tsc && node dist/server.js",
+ "prepublishOnly": "npm run clean && npm run build && npm run test"
+ },
+ "devDependencies": {
+ "@types/cors": "^2.8.0",
+ "@types/express": "^4.17.0",
+ "@types/supertest": "^6.0.0",
+ "@types/swagger-ui-express": "^4.1.0",
+ "supertest": "^6.3.0"
+ },
+ "dependencies": {
+ "cors": "^2.8.5",
+ "express": "^4.18.0",
+ "fmlrunner": "file:../fmlrunner",
+ "swagger-ui-express": "^5.0.0",
+ "winston": "^3.11.0",
+ "yamljs": "^0.3.0"
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner-rest/src/api.ts b/packages/fmlrunner-rest/src/api.ts
new file mode 100644
index 0000000..59e5146
--- /dev/null
+++ b/packages/fmlrunner-rest/src/api.ts
@@ -0,0 +1,1746 @@
+import express, { Request, Response } from 'express';
+import cors from 'cors';
+import { FmlRunner } from 'fmlrunner';
+
+/**
+ * FML Runner API Server implementing the OpenAPI specification
+ */
+export class FmlRunnerApi {
+ private app: express.Application;
+ private fmlRunner: FmlRunner;
+
+ constructor(fmlRunner?: FmlRunner) {
+ this.app = express();
+ this.fmlRunner = fmlRunner || new FmlRunner();
+ this.setupMiddleware();
+ this.setupRoutes();
+ }
+
+ /**
+ * Setup Express middleware
+ */
+ private setupMiddleware(): void {
+ this.app.use(cors());
+ this.app.use(express.json());
+ this.app.use(express.urlencoded({ extended: true }));
+ }
+
+ /**
+ * Setup API routes according to OpenAPI specification
+ */
+ private setupRoutes(): void {
+ const apiRouter = express.Router({ caseSensitive: true });
+
+ // Legacy endpoints for backward compatibility
+ apiRouter.post('/compile', this.compileFml.bind(this));
+ apiRouter.post('/execute', this.executeStructureMap.bind(this));
+ apiRouter.get('/structuremap/:reference', this.getStructureMap.bind(this));
+
+ // FHIR Bundle processing endpoint
+ apiRouter.post('/Bundle', this.processBundle.bind(this));
+ apiRouter.get('/Bundle/summary', this.getBundleSummary.bind(this));
+
+ // FHIR-compliant ConceptMap CRUD endpoints
+ apiRouter.get('/ConceptMap', this.searchConceptMaps.bind(this));
+ apiRouter.get('/ConceptMap/:id', this.getConceptMapById.bind(this));
+ apiRouter.post('/ConceptMap', this.createConceptMap.bind(this));
+ apiRouter.put('/ConceptMap/:id', this.updateConceptMap.bind(this));
+ apiRouter.delete('/ConceptMap/:id', this.deleteConceptMap.bind(this));
+ apiRouter.post('/ConceptMap/\\$translate', this.translateOperation.bind(this));
+
+ // FHIR-compliant ValueSet CRUD endpoints
+ apiRouter.get('/ValueSet', this.searchValueSets.bind(this));
+ apiRouter.get('/ValueSet/:id', this.getValueSetById.bind(this));
+ apiRouter.post('/ValueSet', this.createValueSet.bind(this));
+ apiRouter.put('/ValueSet/:id', this.updateValueSet.bind(this));
+ apiRouter.delete('/ValueSet/:id', this.deleteValueSet.bind(this));
+ apiRouter.post('/ValueSet/:id/\\$expand', this.expandValueSetOperation.bind(this));
+ apiRouter.post('/ValueSet/:id/\\$validate-code', this.validateCodeOperation.bind(this));
+
+ // FHIR-compliant CodeSystem CRUD endpoints
+ apiRouter.get('/CodeSystem', this.searchCodeSystems.bind(this));
+ apiRouter.get('/CodeSystem/:id', this.getCodeSystemById.bind(this));
+ apiRouter.post('/CodeSystem', this.createCodeSystem.bind(this));
+ apiRouter.put('/CodeSystem/:id', this.updateCodeSystem.bind(this));
+ apiRouter.delete('/CodeSystem/:id', this.deleteCodeSystem.bind(this));
+ apiRouter.post('/CodeSystem/:id/\\$lookup', this.lookupOperation.bind(this));
+ apiRouter.post('/CodeSystem/:id/\\$subsumes', this.subsumesOperation.bind(this));
+ apiRouter.post('/CodeSystem/:id/\\$validate-code', this.validateCodeInCodeSystemOperation.bind(this));
+
+ // FHIR-compliant StructureDefinition CRUD endpoints
+ apiRouter.get('/StructureDefinition', this.searchStructureDefinitions.bind(this));
+ apiRouter.get('/StructureDefinition/:id', this.getStructureDefinitionById.bind(this));
+ apiRouter.post('/StructureDefinition', this.createStructureDefinition.bind(this));
+ apiRouter.put('/StructureDefinition/:id', this.updateStructureDefinition.bind(this));
+ apiRouter.delete('/StructureDefinition/:id', this.deleteStructureDefinition.bind(this));
+
+ // FHIR $transform operation (need to register before :id route)
+ apiRouter.post('/StructureMap/:operation(\\$transform)', this.transformOperation.bind(this));
+
+ // FHIR-compliant StructureMap CRUD endpoints
+ apiRouter.get('/StructureMap', this.searchStructureMaps.bind(this));
+ apiRouter.get('/StructureMap/:id', this.getStructureMapById.bind(this));
+ apiRouter.post('/StructureMap', this.createStructureMap.bind(this));
+ apiRouter.put('/StructureMap/:id', this.updateStructureMap.bind(this));
+ apiRouter.delete('/StructureMap/:id', this.deleteStructureMap.bind(this));
+
+ // Enhanced execution with validation
+ apiRouter.post('/execute-with-validation', this.executeWithValidation.bind(this));
+
+ // Validation endpoint
+ apiRouter.post('/validate', this.validateResource.bind(this));
+
+ // Health check endpoint
+ apiRouter.get('/health', this.healthCheck.bind(this));
+
+ this.app.use('/api/v1', apiRouter);
+ }
+
+ /**
+ * Compile FML content to StructureMap
+ */
+ private async compileFml(req: Request, res: Response): Promise {
+ try {
+ const { fmlContent } = req.body;
+
+ if (!fmlContent) {
+ res.status(400).json({
+ error: 'fmlContent is required',
+ details: 'Request body must include fmlContent property'
+ });
+ return;
+ }
+
+ const result = this.fmlRunner.compileFml(fmlContent);
+
+ if (result.success) {
+ res.json(result.structureMap);
+ } else {
+ res.status(400).json({
+ error: 'FML compilation failed',
+ details: result.errors?.join(', ')
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ error: 'Internal server error',
+ details: error instanceof Error ? error.message : 'Unknown error'
+ });
+ }
+ }
+
+ /**
+ * Execute StructureMap transformation
+ */
+ private async executeStructureMap(req: Request, res: Response): Promise {
+ try {
+ const { structureMapReference, inputContent } = req.body;
+
+ if (!structureMapReference || !inputContent) {
+ res.status(400).json({
+ error: 'structureMapReference and inputContent are required',
+ details: 'Request body must include both structureMapReference and inputContent properties'
+ });
+ return;
+ }
+
+ const result = await this.fmlRunner.executeStructureMap(structureMapReference, inputContent);
+
+ if (result.success) {
+ res.json({ result: result.result });
+ } else {
+ res.status(400).json({
+ error: 'StructureMap execution failed',
+ details: result.errors?.join(', ')
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ error: 'Internal server error',
+ details: error instanceof Error ? error.message : 'Unknown error'
+ });
+ }
+ }
+
+ /**
+ * Retrieve StructureMap by reference
+ */
+ private async getStructureMap(req: Request, res: Response): Promise {
+ try {
+ const { reference } = req.params;
+
+ if (!reference) {
+ res.status(400).json({
+ error: 'Reference parameter is required'
+ });
+ return;
+ }
+
+ const structureMap = await this.fmlRunner.getStructureMap(reference);
+
+ if (structureMap) {
+ res.json(structureMap);
+ } else {
+ res.status(404).json({
+ error: 'StructureMap not found',
+ details: `No StructureMap found for reference: ${reference}`
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ error: 'Internal server error',
+ details: error instanceof Error ? error.message : 'Unknown error'
+ });
+ }
+ }
+
+ /**
+ * Search StructureMaps with FHIR search parameters
+ */
+ private async searchStructureMaps(req: Request, res: Response): Promise {
+ try {
+ // FHIR search parameters - basic implementation
+ const { name, status, url, _count = '20', _offset = '0' } = req.query;
+
+ // For now, return empty bundle - would need database/storage implementation
+ const bundle = {
+ resourceType: 'Bundle',
+ type: 'searchset',
+ total: 0,
+ entry: []
+ };
+
+ res.json(bundle);
+ } catch (error) {
+ res.status(500).json({
+ error: 'Internal server error',
+ details: error instanceof Error ? error.message : 'Unknown error'
+ });
+ }
+ }
+
+ /**
+ * Get StructureMap by ID (FHIR-compliant)
+ */
+ private async getStructureMapById(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+
+ // First check registered StructureMaps in memory
+ const registeredMaps = this.fmlRunner.getAllStructureMaps();
+ let structureMap: any = registeredMaps.find(sm => sm.id === id || sm.url === id);
+
+ // If not found in memory, try file system
+ if (!structureMap) {
+ const retrieved = await this.fmlRunner.getStructureMap(id);
+ structureMap = retrieved || null;
+ }
+
+ if (structureMap) {
+ res.json(structureMap);
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `StructureMap with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Create new StructureMap (FHIR-compliant)
+ */
+ private async createStructureMap(req: Request, res: Response): Promise {
+ try {
+ const structureMap = req.body;
+
+ // Basic validation
+ if (!structureMap || structureMap.resourceType !== 'StructureMap') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid StructureMap resource'
+ }]
+ });
+ return;
+ }
+
+ // Assign ID if not present
+ if (!structureMap.id) {
+ structureMap.id = 'sm-' + Date.now();
+ }
+
+ // TODO: Store the StructureMap (would need storage implementation)
+
+ res.status(201).json(structureMap);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Update StructureMap (FHIR-compliant)
+ */
+ private async updateStructureMap(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const structureMap = req.body;
+
+ // Basic validation
+ if (!structureMap || structureMap.resourceType !== 'StructureMap') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid StructureMap resource'
+ }]
+ });
+ return;
+ }
+
+ // Ensure ID matches
+ structureMap.id = id;
+
+ // TODO: Store the StructureMap (would need storage implementation)
+
+ res.json(structureMap);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Delete StructureMap (FHIR-compliant)
+ */
+ private async deleteStructureMap(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+
+ // TODO: Delete the StructureMap (would need storage implementation)
+
+ res.status(204).send();
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * FHIR $transform operation
+ */
+ private async transformOperation(req: Request, res: Response): Promise {
+ try {
+ const parameters = req.body;
+
+ // Validate Parameters resource
+ if (!parameters || parameters.resourceType !== 'Parameters') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a FHIR Parameters resource'
+ }]
+ });
+ return;
+ }
+
+ // Extract source data and StructureMap URL from parameters
+ let sourceData = null;
+ let structureMapUrl = null;
+
+ if (parameters.parameter) {
+ for (const param of parameters.parameter) {
+ if (param.name === 'source') {
+ sourceData = param.resource || param.valueString;
+ } else if (param.name === 'map') {
+ structureMapUrl = param.valueUri || param.valueString;
+ }
+ }
+ }
+
+ if (!sourceData || !structureMapUrl) {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Parameters must include both "source" and "map" parameters'
+ }]
+ });
+ return;
+ }
+
+ // Execute transformation using existing logic
+ const result = await this.fmlRunner.executeStructureMap(structureMapUrl, sourceData);
+
+ if (result.success) {
+ // Return result as Parameters resource
+ const resultParameters = {
+ resourceType: 'Parameters',
+ parameter: [{
+ name: 'result',
+ resource: result.result
+ }]
+ };
+ res.json(resultParameters);
+ } else {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'processing',
+ diagnostics: result.errors?.join(', ') || 'Transformation failed'
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Search StructureDefinitions with FHIR search parameters
+ */
+ private async searchStructureDefinitions(req: Request, res: Response): Promise {
+ try {
+ // FHIR search parameters - basic implementation
+ const { name, status, kind, type, _count = '20', _offset = '0' } = req.query;
+
+ // Get registered StructureDefinitions from validation service
+ const validationService = this.fmlRunner.getValidationService();
+ const structureDefinitions = validationService ? validationService.getStructureDefinitions() : [];
+
+ // Filter based on search parameters (basic implementation)
+ let filteredDefinitions = structureDefinitions;
+
+ if (name) {
+ filteredDefinitions = filteredDefinitions.filter(sd =>
+ sd.name?.toLowerCase().includes((name as string).toLowerCase())
+ );
+ }
+
+ if (status) {
+ filteredDefinitions = filteredDefinitions.filter(sd => sd.status === status);
+ }
+
+ const bundle = {
+ resourceType: 'Bundle',
+ type: 'searchset',
+ total: filteredDefinitions.length,
+ entry: filteredDefinitions.map(sd => ({
+ resource: sd
+ }))
+ };
+
+ res.json(bundle);
+ } catch (error) {
+ res.status(500).json({
+ error: 'Internal server error',
+ details: error instanceof Error ? error.message : 'Unknown error'
+ });
+ }
+ }
+
+ /**
+ * Get StructureDefinition by ID
+ */
+ private async getStructureDefinitionById(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+
+ // This would need a proper storage implementation
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `StructureDefinition with id '${id}' not found`
+ }]
+ });
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Create new StructureDefinition
+ */
+ private async createStructureDefinition(req: Request, res: Response): Promise {
+ try {
+ const structureDefinition = req.body;
+
+ // Basic validation
+ if (!structureDefinition || structureDefinition.resourceType !== 'StructureDefinition') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid StructureDefinition resource'
+ }]
+ });
+ return;
+ }
+
+ // Assign ID if not present
+ if (!structureDefinition.id) {
+ structureDefinition.id = 'sd-' + Date.now();
+ }
+
+ // Register with validation service
+ const validationService = this.fmlRunner.getValidationService();
+ if (validationService) {
+ validationService.registerStructureDefinition(structureDefinition);
+ }
+
+ res.status(201).json(structureDefinition);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Update StructureDefinition
+ */
+ private async updateStructureDefinition(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const structureDefinition = req.body;
+
+ // Basic validation
+ if (!structureDefinition || structureDefinition.resourceType !== 'StructureDefinition') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid StructureDefinition resource'
+ }]
+ });
+ return;
+ }
+
+ // Ensure ID matches
+ structureDefinition.id = id;
+
+ // Register with validation service
+ const validationService = this.fmlRunner.getValidationService();
+ if (validationService) {
+ validationService.registerStructureDefinition(structureDefinition);
+ }
+
+ res.json(structureDefinition);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Delete StructureDefinition
+ */
+ private async deleteStructureDefinition(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+
+ // TODO: Remove from validation service
+
+ res.status(204).send();
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Execute StructureMap with validation
+ */
+ private async executeWithValidation(req: Request, res: Response): Promise {
+ try {
+ const { structureMapReference, inputContent, options } = req.body;
+
+ if (!structureMapReference || !inputContent) {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'structureMapReference and inputContent are required'
+ }]
+ });
+ return;
+ }
+
+ const result = await this.fmlRunner.executeStructureMapWithValidation(
+ structureMapReference,
+ inputContent,
+ options
+ );
+
+ if (result.success) {
+ res.json({
+ result: result.result,
+ validation: result.validation
+ });
+ } else {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'processing',
+ diagnostics: result.errors?.join(', ') || 'Execution failed'
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Validate a resource against a StructureDefinition
+ */
+ private async validateResource(req: Request, res: Response): Promise {
+ try {
+ const { resource, profile } = req.body;
+
+ if (!resource || !profile) {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Both resource and profile are required'
+ }]
+ });
+ return;
+ }
+
+ const validationService = this.fmlRunner.getValidationService();
+ if (!validationService) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-supported',
+ diagnostics: 'Validation service not available'
+ }]
+ });
+ return;
+ }
+
+ const validationResult = validationService.validate(resource, profile);
+
+ const operationOutcome = {
+ resourceType: 'OperationOutcome',
+ issue: [
+ ...validationResult.errors.map(error => ({
+ severity: 'error' as const,
+ code: 'invariant' as const,
+ diagnostics: error.message,
+ location: [error.path]
+ })),
+ ...validationResult.warnings.map(warning => ({
+ severity: 'warning' as const,
+ code: 'informational' as const,
+ diagnostics: warning.message,
+ location: [warning.path]
+ }))
+ ]
+ };
+
+ if (validationResult.valid) {
+ res.json(operationOutcome);
+ } else {
+ res.status(400).json(operationOutcome);
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Health check endpoint
+ */
+ private healthCheck(req: Request, res: Response): void {
+ res.json({
+ status: 'healthy',
+ timestamp: new Date().toISOString(),
+ version: '0.1.0',
+ resources: this.fmlRunner.getBundleStats()
+ });
+ }
+
+ // ============================================
+ // BUNDLE PROCESSING ENDPOINTS
+ // ============================================
+
+ /**
+ * Process FHIR Bundle and load resources
+ */
+ private async processBundle(req: Request, res: Response): Promise {
+ try {
+ const bundle = req.body;
+
+ if (!bundle || bundle.resourceType !== 'Bundle') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid Bundle resource'
+ }]
+ });
+ return;
+ }
+
+ const result = this.fmlRunner.processBundle(bundle);
+
+ if (result.success) {
+ res.status(201).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'information',
+ code: 'informational',
+ diagnostics: `Successfully processed bundle. Loaded: ${result.processed.structureMaps} StructureMaps, ${result.processed.structureDefinitions} StructureDefinitions, ${result.processed.conceptMaps} ConceptMaps, ${result.processed.valueSets} ValueSets, ${result.processed.codeSystems} CodeSystems`
+ }]
+ });
+ } else {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'processing',
+ diagnostics: `Bundle processing failed: ${result.errors.join(', ')}`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Get bundle summary of loaded resources
+ */
+ private async getBundleSummary(req: Request, res: Response): Promise {
+ try {
+ const summaryBundle = this.fmlRunner.createResourceSummaryBundle();
+ res.json(summaryBundle);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ // ============================================
+ // CONCEPTMAP CRUD ENDPOINTS
+ // ============================================
+
+ /**
+ * Search ConceptMaps
+ */
+ private async searchConceptMaps(req: Request, res: Response): Promise {
+ try {
+ const { name, status, url, source, target, _count = '20', _offset = '0' } = req.query;
+
+ const conceptMaps = this.fmlRunner.searchConceptMaps({
+ name: name as string,
+ status: status as string,
+ url: url as string,
+ source: source as string,
+ target: target as string
+ });
+
+ const bundle = {
+ resourceType: 'Bundle',
+ type: 'searchset',
+ total: conceptMaps.length,
+ entry: conceptMaps.map(cm => ({
+ resource: cm
+ }))
+ };
+
+ res.json(bundle);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Get ConceptMap by ID
+ */
+ private async getConceptMapById(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const conceptMap = this.fmlRunner.getConceptMap(id);
+
+ if (conceptMap) {
+ res.json(conceptMap);
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `ConceptMap with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Create ConceptMap
+ */
+ private async createConceptMap(req: Request, res: Response): Promise {
+ try {
+ const conceptMap = req.body;
+
+ if (!conceptMap || conceptMap.resourceType !== 'ConceptMap') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid ConceptMap resource'
+ }]
+ });
+ return;
+ }
+
+ if (!conceptMap.id) {
+ conceptMap.id = 'cm-' + Date.now();
+ }
+
+ this.fmlRunner.registerConceptMap(conceptMap);
+ res.status(201).json(conceptMap);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Update ConceptMap
+ */
+ private async updateConceptMap(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const conceptMap = req.body;
+
+ if (!conceptMap || conceptMap.resourceType !== 'ConceptMap') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid ConceptMap resource'
+ }]
+ });
+ return;
+ }
+
+ conceptMap.id = id;
+ this.fmlRunner.registerConceptMap(conceptMap);
+ res.json(conceptMap);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Delete ConceptMap
+ */
+ private async deleteConceptMap(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const success = this.fmlRunner.removeConceptMap(id);
+
+ if (success) {
+ res.status(204).send();
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `ConceptMap with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * ConceptMap $translate operation
+ */
+ private async translateOperation(req: Request, res: Response): Promise {
+ try {
+ const parameters = req.body;
+
+ if (!parameters || parameters.resourceType !== 'Parameters') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a FHIR Parameters resource'
+ }]
+ });
+ return;
+ }
+
+ let system: string | undefined;
+ let code: string | undefined;
+ let target: string | undefined;
+
+ if (parameters.parameter) {
+ for (const param of parameters.parameter) {
+ if (param.name === 'system') {
+ system = param.valueUri || param.valueString;
+ } else if (param.name === 'code') {
+ code = param.valueCode || param.valueString;
+ } else if (param.name === 'target') {
+ target = param.valueUri || param.valueString;
+ }
+ }
+ }
+
+ if (!system || !code) {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Parameters must include both "system" and "code" parameters'
+ }]
+ });
+ return;
+ }
+
+ const translations = this.fmlRunner.translateCode(system, code, target);
+
+ const resultParameters = {
+ resourceType: 'Parameters',
+ parameter: translations.map(t => ({
+ name: 'match',
+ part: [
+ { name: 'equivalence', valueCode: t.equivalence },
+ ...(t.system ? [{ name: 'concept', valueCoding: { system: t.system, code: t.code, display: t.display } }] : [])
+ ]
+ }))
+ };
+
+ res.json(resultParameters);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ // ============================================
+ // VALUESET CRUD ENDPOINTS
+ // ============================================
+
+ /**
+ * Search ValueSets
+ */
+ private async searchValueSets(req: Request, res: Response): Promise {
+ try {
+ const { name, status, url, publisher, jurisdiction, _count = '20', _offset = '0' } = req.query;
+
+ const valueSets = this.fmlRunner.searchValueSets({
+ name: name as string,
+ status: status as string,
+ url: url as string,
+ publisher: publisher as string,
+ jurisdiction: jurisdiction as string
+ });
+
+ const bundle = {
+ resourceType: 'Bundle',
+ type: 'searchset',
+ total: valueSets.length,
+ entry: valueSets.map(vs => ({
+ resource: vs
+ }))
+ };
+
+ res.json(bundle);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Get ValueSet by ID
+ */
+ private async getValueSetById(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const valueSet = this.fmlRunner.getValueSet(id);
+
+ if (valueSet) {
+ res.json(valueSet);
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `ValueSet with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Create ValueSet
+ */
+ private async createValueSet(req: Request, res: Response): Promise {
+ try {
+ const valueSet = req.body;
+
+ if (!valueSet || valueSet.resourceType !== 'ValueSet') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid ValueSet resource'
+ }]
+ });
+ return;
+ }
+
+ if (!valueSet.id) {
+ valueSet.id = 'vs-' + Date.now();
+ }
+
+ this.fmlRunner.registerValueSet(valueSet);
+ res.status(201).json(valueSet);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Update ValueSet
+ */
+ private async updateValueSet(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const valueSet = req.body;
+
+ if (!valueSet || valueSet.resourceType !== 'ValueSet') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid ValueSet resource'
+ }]
+ });
+ return;
+ }
+
+ valueSet.id = id;
+ this.fmlRunner.registerValueSet(valueSet);
+ res.json(valueSet);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Delete ValueSet
+ */
+ private async deleteValueSet(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const success = this.fmlRunner.removeValueSet(id);
+
+ if (success) {
+ res.status(204).send();
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `ValueSet with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * ValueSet $expand operation
+ */
+ private async expandValueSetOperation(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const parameters = req.body;
+
+ let count: number | undefined;
+ let offset: number | undefined;
+
+ if (parameters?.parameter) {
+ for (const param of parameters.parameter) {
+ if (param.name === 'count') {
+ count = param.valueInteger;
+ } else if (param.name === 'offset') {
+ offset = param.valueInteger;
+ }
+ }
+ }
+
+ const expandedValueSet = this.fmlRunner.expandValueSet(id, count, offset);
+
+ if (expandedValueSet) {
+ res.json(expandedValueSet);
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `ValueSet with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * ValueSet $validate-code operation
+ */
+ private async validateCodeOperation(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const parameters = req.body;
+
+ let system: string | undefined;
+ let code: string | undefined;
+ let display: string | undefined;
+
+ if (parameters?.parameter) {
+ for (const param of parameters.parameter) {
+ if (param.name === 'system') {
+ system = param.valueUri || param.valueString;
+ } else if (param.name === 'code') {
+ code = param.valueCode || param.valueString;
+ } else if (param.name === 'display') {
+ display = param.valueString;
+ }
+ }
+ }
+
+ const validation = this.fmlRunner.validateCodeInValueSet(id, system, code, display);
+
+ const resultParameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'result', valueBoolean: validation.result },
+ ...(validation.message ? [{ name: 'message', valueString: validation.message }] : [])
+ ]
+ };
+
+ res.json(resultParameters);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ // ============================================
+ // CODESYSTEM CRUD ENDPOINTS
+ // ============================================
+
+ /**
+ * Search CodeSystems
+ */
+ private async searchCodeSystems(req: Request, res: Response): Promise {
+ try {
+ const { name, status, url, system, publisher, content, _count = '20', _offset = '0' } = req.query;
+
+ const codeSystems = this.fmlRunner.searchCodeSystems({
+ name: name as string,
+ status: status as string,
+ url: url as string,
+ system: system as string,
+ publisher: publisher as string,
+ content: content as string
+ });
+
+ const bundle = {
+ resourceType: 'Bundle',
+ type: 'searchset',
+ total: codeSystems.length,
+ entry: codeSystems.map(cs => ({
+ resource: cs
+ }))
+ };
+
+ res.json(bundle);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Get CodeSystem by ID
+ */
+ private async getCodeSystemById(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const codeSystem = this.fmlRunner.getCodeSystem(id);
+
+ if (codeSystem) {
+ res.json(codeSystem);
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `CodeSystem with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Create CodeSystem
+ */
+ private async createCodeSystem(req: Request, res: Response): Promise {
+ try {
+ const codeSystem = req.body;
+
+ if (!codeSystem || codeSystem.resourceType !== 'CodeSystem') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid CodeSystem resource'
+ }]
+ });
+ return;
+ }
+
+ if (!codeSystem.id) {
+ codeSystem.id = 'cs-' + Date.now();
+ }
+
+ this.fmlRunner.registerCodeSystem(codeSystem);
+ res.status(201).json(codeSystem);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Update CodeSystem
+ */
+ private async updateCodeSystem(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const codeSystem = req.body;
+
+ if (!codeSystem || codeSystem.resourceType !== 'CodeSystem') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid CodeSystem resource'
+ }]
+ });
+ return;
+ }
+
+ codeSystem.id = id;
+ this.fmlRunner.registerCodeSystem(codeSystem);
+ res.json(codeSystem);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Delete CodeSystem
+ */
+ private async deleteCodeSystem(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const success = this.fmlRunner.removeCodeSystem(id);
+
+ if (success) {
+ res.status(204).send();
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `CodeSystem with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * CodeSystem $lookup operation
+ */
+ private async lookupOperation(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const parameters = req.body;
+
+ let code: string | undefined;
+ let property: string[] | undefined;
+
+ if (parameters?.parameter) {
+ for (const param of parameters.parameter) {
+ if (param.name === 'code') {
+ code = param.valueCode || param.valueString;
+ } else if (param.name === 'property') {
+ property = property || [];
+ property.push(param.valueCode || param.valueString);
+ }
+ }
+ }
+
+ if (!code) {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Parameters must include "code" parameter'
+ }]
+ });
+ return;
+ }
+
+ const lookup = this.fmlRunner.lookupConcept(id, code, property);
+
+ if (lookup) {
+ const resultParameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'name', valueString: lookup.name },
+ ...(lookup.display ? [{ name: 'display', valueString: lookup.display }] : []),
+ ...(lookup.definition ? [{ name: 'definition', valueString: lookup.definition }] : []),
+ ...(lookup.designation ? lookup.designation.map((d: any) => ({
+ name: 'designation',
+ part: [
+ ...(d.language ? [{ name: 'language', valueCode: d.language }] : []),
+ ...(d.use ? [{ name: 'use', valueCoding: d.use }] : []),
+ { name: 'value', valueString: d.value }
+ ]
+ })) : []),
+ ...(lookup.property ? lookup.property.map((p: any) => ({
+ name: 'property',
+ part: [
+ { name: 'code', valueCode: p.code },
+ ...(p.valueCode ? [{ name: 'value', valueCode: p.valueCode }] : []),
+ ...(p.valueString ? [{ name: 'value', valueString: p.valueString }] : []),
+ ...(p.valueInteger ? [{ name: 'value', valueInteger: p.valueInteger }] : []),
+ ...(p.valueBoolean !== undefined ? [{ name: 'value', valueBoolean: p.valueBoolean }] : [])
+ ]
+ })) : [])
+ ]
+ };
+
+ res.json(resultParameters);
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `Code '${code}' not found in CodeSystem '${id}'`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * CodeSystem $subsumes operation
+ */
+ private async subsumesOperation(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const parameters = req.body;
+
+ let codeA: string | undefined;
+ let codeB: string | undefined;
+
+ if (parameters?.parameter) {
+ for (const param of parameters.parameter) {
+ if (param.name === 'codeA') {
+ codeA = param.valueCode || param.valueString;
+ } else if (param.name === 'codeB') {
+ codeB = param.valueCode || param.valueString;
+ }
+ }
+ }
+
+ if (!codeA || !codeB) {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Parameters must include both "codeA" and "codeB" parameters'
+ }]
+ });
+ return;
+ }
+
+ const result = this.fmlRunner.testSubsumption(id, codeA, codeB);
+
+ const resultParameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'outcome', valueCode: result }
+ ]
+ };
+
+ res.json(resultParameters);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * CodeSystem $validate-code operation
+ */
+ private async validateCodeInCodeSystemOperation(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const parameters = req.body;
+
+ let code: string | undefined;
+ let display: string | undefined;
+
+ if (parameters?.parameter) {
+ for (const param of parameters.parameter) {
+ if (param.name === 'code') {
+ code = param.valueCode || param.valueString;
+ } else if (param.name === 'display') {
+ display = param.valueString;
+ }
+ }
+ }
+
+ if (!code) {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Parameters must include "code" parameter'
+ }]
+ });
+ return;
+ }
+
+ const validation = this.fmlRunner.validateCodeInCodeSystem(id, code, display);
+
+ const resultParameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'result', valueBoolean: validation.result },
+ ...(validation.display ? [{ name: 'display', valueString: validation.display }] : []),
+ ...(validation.message ? [{ name: 'message', valueString: validation.message }] : [])
+ ]
+ };
+
+ res.json(resultParameters);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Get Express application instance
+ */
+ getApp(): express.Application {
+ return this.app;
+ }
+
+ /**
+ * Start the server
+ */
+ listen(port: number = 3000): void {
+ this.app.listen(port, () => {
+ console.log(`FML Runner API server listening on port ${port}`);
+ });
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner-rest/src/server.ts b/packages/fmlrunner-rest/src/server.ts
new file mode 100644
index 0000000..002118f
--- /dev/null
+++ b/packages/fmlrunner-rest/src/server.ts
@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+import { FmlRunnerApi } from './api';
+import { FmlRunner } from 'fmlrunner';
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs(): { port: number; baseUrl: string } {
+ const args = process.argv.slice(2);
+ let port = parseInt(process.env.PORT || '3000', 10);
+ let baseUrl = process.env.BASE_URL || './maps';
+
+ for (let i = 0; i < args.length; i++) {
+ const arg = args[i];
+ if (arg === '--port' || arg === '-p') {
+ const portValue = args[i + 1];
+ if (portValue) {
+ const parsedPort = parseInt(portValue, 10);
+ if (!isNaN(parsedPort) && parsedPort > 0 && parsedPort <= 65535) {
+ port = parsedPort;
+ i++; // Skip the next argument as it's the port value
+ } else {
+ console.error(`Invalid port value: ${portValue}`);
+ process.exit(1);
+ }
+ }
+ } else if (arg === '--base-url' || arg === '-b') {
+ const baseUrlValue = args[i + 1];
+ if (baseUrlValue) {
+ baseUrl = baseUrlValue;
+ i++; // Skip the next argument as it's the base URL value
+ }
+ } else if (arg === '--help' || arg === '-h') {
+ console.log(`
+FML Runner REST API Server
+
+Usage: fmlrunner-rest [options]
+
+Options:
+ -p, --port Port to listen on (default: 3000, env: PORT)
+ -b, --base-url Base directory for StructureMaps (default: ./maps, env: BASE_URL)
+ -h, --help Show this help message
+
+Environment Variables:
+ PORT Port to listen on
+ BASE_URL Base directory for StructureMaps
+ `);
+ process.exit(0);
+ }
+ }
+
+ return { port, baseUrl };
+}
+
+/**
+ * Standalone server entry point
+ */
+function main() {
+ const { port, baseUrl } = parseArgs();
+
+ const fmlRunner = new FmlRunner({ baseUrl, logLevel: 'info' });
+ const api = new FmlRunnerApi(fmlRunner);
+
+ api.listen(port);
+ console.log(`FML Runner REST API server started on port ${port}`);
+ console.log(`Base directory for StructureMaps: ${baseUrl}`);
+}
+
+if (require.main === module) {
+ main();
+}
\ No newline at end of file
diff --git a/packages/fmlrunner-rest/tests/api.test.ts b/packages/fmlrunner-rest/tests/api.test.ts
new file mode 100644
index 0000000..05ad591
--- /dev/null
+++ b/packages/fmlrunner-rest/tests/api.test.ts
@@ -0,0 +1,8 @@
+import { FmlRunnerApi } from '../src/api';
+
+describe('FML Runner REST API', () => {
+ test('should create API instance', () => {
+ const api = new FmlRunnerApi({});
+ expect(api).toBeDefined();
+ });
+});
\ No newline at end of file
diff --git a/packages/fmlrunner-rest/tsconfig.json b/packages/fmlrunner-rest/tsconfig.json
new file mode 100644
index 0000000..aba4d5c
--- /dev/null
+++ b/packages/fmlrunner-rest/tsconfig.json
@@ -0,0 +1,18 @@
+{
+ "compilerOptions": {
+ "target": "ES2020",
+ "module": "commonjs",
+ "lib": ["ES2020"],
+ "outDir": "./dist",
+ "rootDir": "./src",
+ "strict": true,
+ "esModuleInterop": true,
+ "skipLibCheck": true,
+ "forceConsistentCasingInFileNames": true,
+ "declaration": true,
+ "declarationMap": true,
+ "sourceMap": true
+ },
+ "include": ["src/**/*"],
+ "exclude": ["node_modules", "dist", "tests"]
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/.npmignore b/packages/fmlrunner/.npmignore
new file mode 100644
index 0000000..2a6ebf0
--- /dev/null
+++ b/packages/fmlrunner/.npmignore
@@ -0,0 +1,103 @@
+# Development files
+src/
+tests/
+*.test.ts
+*.spec.ts
+.eslintrc.*
+jest.config.*
+tsconfig.json
+
+# Build artifacts
+*.tsbuildinfo
+coverage/
+.nyc_output/
+
+# IDE and editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids/
+*.pid
+*.seed
+*.pid.lock
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+.env.test
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# next.js build output
+.next
+
+# nuxt.js build output
+.nuxt
+
+# gatsby files
+.cache/
+public
+
+# vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
\ No newline at end of file
diff --git a/packages/fmlrunner/jest.config.js b/packages/fmlrunner/jest.config.js
new file mode 100644
index 0000000..0be3fa7
--- /dev/null
+++ b/packages/fmlrunner/jest.config.js
@@ -0,0 +1,10 @@
+module.exports = {
+ preset: 'ts-jest',
+ testEnvironment: 'node',
+ roots: ['/tests'],
+ testMatch: ['**/*.test.ts'],
+ collectCoverageFrom: [
+ 'src/**/*.ts',
+ '!src/**/*.d.ts',
+ ]
+};
\ No newline at end of file
diff --git a/packages/fmlrunner/package.json b/packages/fmlrunner/package.json
new file mode 100644
index 0000000..0ca4784
--- /dev/null
+++ b/packages/fmlrunner/package.json
@@ -0,0 +1,62 @@
+{
+ "name": "fmlrunner",
+ "version": "0.1.0",
+ "description": "Core FML (FHIR Mapping Language) library for compiling and executing FHIR StructureMaps with comprehensive validation and terminology support",
+ "keywords": [
+ "fhir",
+ "fml",
+ "mapping",
+ "transformation",
+ "healthcare",
+ "structuremap",
+ "hl7",
+ "jsonschema",
+ "conceptmap",
+ "valueset",
+ "terminology",
+ "fhirpath"
+ ],
+ "publishConfig": {
+ "access": "public",
+ "registry": "https://registry.npmjs.org/"
+ },
+ "author": "Carl Leitner",
+ "license": "MIT",
+ "homepage": "https://github.com/litlfred/fmlrunner#readme",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/litlfred/fmlrunner.git"
+ },
+ "bugs": {
+ "url": "https://github.com/litlfred/fmlrunner/issues"
+ },
+ "engines": {
+ "node": ">=16.0.0",
+ "npm": ">=8.0.0"
+ },
+ "main": "dist/index.js",
+ "types": "dist/index.d.ts",
+ "files": [
+ "dist/",
+ "schemas/",
+ "README.md",
+ "LICENSE"
+ ],
+ "scripts": {
+ "build": "tsc",
+ "test": "jest",
+ "lint": "eslint src/**/*.ts",
+ "clean": "rm -rf dist",
+ "validate-schemas": "ajv compile -s schemas/*.json",
+ "prepublishOnly": "npm run clean && npm run build && npm run test"
+ },
+ "devDependencies": {
+ "ajv-cli": "^5.0.0"
+ },
+ "dependencies": {
+ "ajv": "^8.12.0",
+ "ajv-formats": "^2.1.1",
+ "fhirpath": "^4.6.0",
+ "winston": "^3.11.0"
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/schemas/fml-input.schema.json b/packages/fmlrunner/schemas/fml-input.schema.json
new file mode 100644
index 0000000..9048e1c
--- /dev/null
+++ b/packages/fmlrunner/schemas/fml-input.schema.json
@@ -0,0 +1,12 @@
+{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "$id": "fml-input.schema.json",
+ "title": "FML Input Schema",
+ "description": "Schema for validating FHIR Mapping Language (FML) input content",
+ "type": "string",
+ "minLength": 1,
+ "pattern": "^map\\s+",
+ "examples": [
+ "map \"http://example.org/fml/example\" = \"ExampleMap\"\n\nuses \"http://hl7.org/fhir/StructureDefinition/Patient\" alias Patient as source"
+ ]
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/schemas/structure-map.schema.json b/packages/fmlrunner/schemas/structure-map.schema.json
new file mode 100644
index 0000000..d956a01
--- /dev/null
+++ b/packages/fmlrunner/schemas/structure-map.schema.json
@@ -0,0 +1,166 @@
+{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "$id": "structure-map.schema.json",
+ "title": "FHIR StructureMap Schema",
+ "description": "Schema for validating FHIR StructureMap resources",
+ "type": "object",
+ "properties": {
+ "resourceType": {
+ "type": "string",
+ "const": "StructureMap"
+ },
+ "id": {
+ "type": "string",
+ "pattern": "^[A-Za-z0-9\\-\\.]{1,64}$"
+ },
+ "url": {
+ "type": "string",
+ "format": "uri"
+ },
+ "name": {
+ "type": "string",
+ "minLength": 1
+ },
+ "title": {
+ "type": "string"
+ },
+ "status": {
+ "type": "string",
+ "enum": ["draft", "active", "retired", "unknown"]
+ },
+ "experimental": {
+ "type": "boolean"
+ },
+ "description": {
+ "type": "string"
+ },
+ "group": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/StructureMapGroup"
+ },
+ "minItems": 1
+ }
+ },
+ "required": ["resourceType", "group"],
+ "additionalProperties": true,
+ "definitions": {
+ "StructureMapGroup": {
+ "type": "object",
+ "properties": {
+ "name": {
+ "type": "string",
+ "minLength": 1
+ },
+ "typeMode": {
+ "type": "string",
+ "enum": ["none", "types", "type-and-types"]
+ },
+ "documentation": {
+ "type": "string"
+ },
+ "input": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/StructureMapGroupInput"
+ }
+ },
+ "rule": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/StructureMapGroupRule"
+ }
+ }
+ },
+ "required": ["name", "input"],
+ "additionalProperties": true
+ },
+ "StructureMapGroupInput": {
+ "type": "object",
+ "properties": {
+ "name": {
+ "type": "string",
+ "minLength": 1
+ },
+ "type": {
+ "type": "string"
+ },
+ "mode": {
+ "type": "string",
+ "enum": ["source", "target"]
+ },
+ "documentation": {
+ "type": "string"
+ }
+ },
+ "required": ["name", "mode"],
+ "additionalProperties": true
+ },
+ "StructureMapGroupRule": {
+ "type": "object",
+ "properties": {
+ "name": {
+ "type": "string"
+ },
+ "source": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/StructureMapGroupRuleSource"
+ },
+ "minItems": 1
+ },
+ "target": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/StructureMapGroupRuleTarget"
+ }
+ },
+ "documentation": {
+ "type": "string"
+ }
+ },
+ "required": ["source"],
+ "additionalProperties": true
+ },
+ "StructureMapGroupRuleSource": {
+ "type": "object",
+ "properties": {
+ "context": {
+ "type": "string",
+ "minLength": 1
+ },
+ "element": {
+ "type": "string"
+ },
+ "variable": {
+ "type": "string"
+ },
+ "type": {
+ "type": "string"
+ },
+ "min": {
+ "type": "integer",
+ "minimum": 0
+ },
+ "max": {
+ "type": "string"
+ }
+ },
+ "required": ["context"],
+ "additionalProperties": true
+ },
+ "StructureMapGroupRuleTarget": {
+ "type": "object",
+ "properties": {
+ "context": {
+ "type": "string"
+ },
+ "contextType": {
+ "type": "string",
+ "enum": ["variable", "type"]
+ }
+ },
+ "additionalProperties": true
+ }
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/bundle-service.ts b/packages/fmlrunner/src/bundle-service.ts
new file mode 100644
index 0000000..0c6576c
--- /dev/null
+++ b/packages/fmlrunner/src/bundle-service.ts
@@ -0,0 +1,307 @@
+import { Bundle, BundleEntry, StructureMap, StructureDefinition, ConceptMap, ValueSet, CodeSystem } from './types';
+import { ConceptMapService } from './conceptmap-service';
+import { ValueSetService } from './valueset-service';
+import { CodeSystemService } from './codesystem-service';
+import { ValidationService } from './validation-service';
+
+/**
+ * Result of processing a bundle
+ */
+export interface BundleProcessingResult {
+ success: boolean;
+ processed: {
+ structureMaps: number;
+ structureDefinitions: number;
+ conceptMaps: number;
+ valueSets: number;
+ codeSystems: number;
+ other: number;
+ };
+ errors: string[];
+ warnings: string[];
+}
+
+/**
+ * Service for processing FHIR Bundles and distributing resources to appropriate services
+ */
+export class BundleService {
+ constructor(
+ private conceptMapService: ConceptMapService,
+ private valueSetService: ValueSetService,
+ private codeSystemService: CodeSystemService,
+ private validationService?: ValidationService,
+ private structureMapStore?: Map
+ ) {}
+
+ /**
+ * Process a FHIR Bundle and register all contained resources
+ */
+ processBundle(bundle: Bundle): BundleProcessingResult {
+ const result: BundleProcessingResult = {
+ success: true,
+ processed: {
+ structureMaps: 0,
+ structureDefinitions: 0,
+ conceptMaps: 0,
+ valueSets: 0,
+ codeSystems: 0,
+ other: 0
+ },
+ errors: [],
+ warnings: []
+ };
+
+ if (!bundle.entry || bundle.entry.length === 0) {
+ result.warnings.push('Bundle contains no entries');
+ return result;
+ }
+
+ for (let i = 0; i < bundle.entry.length; i++) {
+ const entry = bundle.entry[i];
+
+ try {
+ this.processEntry(entry, i, result);
+ } catch (error) {
+ const errorMsg = `Error processing entry ${i}: ${error instanceof Error ? error.message : 'Unknown error'}`;
+ result.errors.push(errorMsg);
+ result.success = false;
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Process a single bundle entry
+ */
+ private processEntry(entry: BundleEntry, index: number, result: BundleProcessingResult): void {
+ if (!entry.resource) {
+ result.warnings.push(`Entry ${index} has no resource`);
+ return;
+ }
+
+ const resource = entry.resource;
+
+ switch (resource.resourceType) {
+ case 'StructureMap':
+ this.processStructureMap(resource as StructureMap, index, result);
+ break;
+
+ case 'StructureDefinition':
+ this.processStructureDefinition(resource as StructureDefinition, index, result);
+ break;
+
+ case 'ConceptMap':
+ this.processConceptMap(resource as ConceptMap, index, result);
+ break;
+
+ case 'ValueSet':
+ this.processValueSet(resource as ValueSet, index, result);
+ break;
+
+ case 'CodeSystem':
+ this.processCodeSystem(resource as CodeSystem, index, result);
+ break;
+
+ default:
+ result.processed.other++;
+ result.warnings.push(`Entry ${index}: Unsupported resource type '${resource.resourceType}'`);
+ }
+ }
+
+ /**
+ * Process StructureMap resource
+ */
+ private processStructureMap(structureMap: StructureMap, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!structureMap.id && !structureMap.url) {
+ result.warnings.push(`Entry ${index}: StructureMap has no id or url, skipping`);
+ return;
+ }
+
+ // Store in StructureMap store if available
+ if (this.structureMapStore) {
+ if (structureMap.id) {
+ this.structureMapStore.set(structureMap.id, structureMap);
+ }
+ if (structureMap.url) {
+ this.structureMapStore.set(structureMap.url, structureMap);
+ }
+ }
+
+ result.processed.structureMaps++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process StructureMap - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Process StructureDefinition resource
+ */
+ private processStructureDefinition(structureDefinition: StructureDefinition, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!structureDefinition.id && !structureDefinition.url) {
+ result.warnings.push(`Entry ${index}: StructureDefinition has no id or url, skipping`);
+ return;
+ }
+
+ // Register with validation service if available
+ if (this.validationService) {
+ this.validationService.registerStructureDefinition(structureDefinition);
+ }
+
+ result.processed.structureDefinitions++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process StructureDefinition - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Process ConceptMap resource
+ */
+ private processConceptMap(conceptMap: ConceptMap, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!conceptMap.id && !conceptMap.url) {
+ result.warnings.push(`Entry ${index}: ConceptMap has no id or url, skipping`);
+ return;
+ }
+
+ this.conceptMapService.registerConceptMap(conceptMap);
+ result.processed.conceptMaps++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process ConceptMap - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Process ValueSet resource
+ */
+ private processValueSet(valueSet: ValueSet, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!valueSet.id && !valueSet.url) {
+ result.warnings.push(`Entry ${index}: ValueSet has no id or url, skipping`);
+ return;
+ }
+
+ this.valueSetService.registerValueSet(valueSet);
+ result.processed.valueSets++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process ValueSet - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Process CodeSystem resource
+ */
+ private processCodeSystem(codeSystem: CodeSystem, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!codeSystem.id && !codeSystem.url) {
+ result.warnings.push(`Entry ${index}: CodeSystem has no id or url, skipping`);
+ return;
+ }
+
+ this.codeSystemService.registerCodeSystem(codeSystem);
+ result.processed.codeSystems++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process CodeSystem - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Create a summary bundle of all loaded resources
+ */
+ createSummaryBundle(): Bundle {
+ const entries: BundleEntry[] = [];
+
+ // Add StructureMaps
+ if (this.structureMapStore) {
+ const uniqueStructureMaps = new Map();
+ this.structureMapStore.forEach((sm) => {
+ const key = sm.id || sm.url || Math.random().toString();
+ uniqueStructureMaps.set(key, sm);
+ });
+
+ uniqueStructureMaps.forEach((sm) => {
+ entries.push({
+ fullUrl: sm.url || `StructureMap/${sm.id}`,
+ resource: sm
+ });
+ });
+ }
+
+ // Add StructureDefinitions
+ if (this.validationService) {
+ const structureDefinitions = this.validationService.getStructureDefinitions();
+ structureDefinitions.forEach((sd) => {
+ entries.push({
+ fullUrl: sd.url || `StructureDefinition/${sd.id}`,
+ resource: sd
+ });
+ });
+ }
+
+ // Add ConceptMaps
+ this.conceptMapService.getAllConceptMaps().forEach((cm) => {
+ entries.push({
+ fullUrl: cm.url || `ConceptMap/${cm.id}`,
+ resource: cm
+ });
+ });
+
+ // Add ValueSets
+ this.valueSetService.getAllValueSets().forEach((vs) => {
+ entries.push({
+ fullUrl: vs.url || `ValueSet/${vs.id}`,
+ resource: vs
+ });
+ });
+
+ // Add CodeSystems
+ this.codeSystemService.getAllCodeSystems().forEach((cs) => {
+ entries.push({
+ fullUrl: cs.url || `CodeSystem/${cs.id}`,
+ resource: cs
+ });
+ });
+
+ return {
+ resourceType: 'Bundle',
+ id: 'loaded-resources-' + Date.now(),
+ type: 'collection',
+ timestamp: new Date().toISOString(),
+ total: entries.length,
+ entry: entries
+ };
+ }
+
+ /**
+ * Clear all loaded resources
+ */
+ clearAll(): void {
+ this.conceptMapService.clear();
+ this.valueSetService.clear();
+ this.codeSystemService.clear();
+ if (this.structureMapStore) {
+ this.structureMapStore.clear();
+ }
+ }
+
+ /**
+ * Get loading statistics
+ */
+ getStats(): {
+ structureMaps: number;
+ structureDefinitions: number;
+ conceptMaps: number;
+ valueSets: number;
+ codeSystems: number;
+ } {
+ return {
+ structureMaps: this.structureMapStore ? Array.from(new Set(Array.from(this.structureMapStore.values()).map(sm => sm.id || sm.url))).length : 0,
+ structureDefinitions: this.validationService ? this.validationService.getStructureDefinitions().length : 0,
+ conceptMaps: this.conceptMapService.getCount(),
+ valueSets: this.valueSetService.getCount(),
+ codeSystems: this.codeSystemService.getCount()
+ };
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/codesystem-service.ts b/packages/fmlrunner/src/codesystem-service.ts
new file mode 100644
index 0000000..f98a0b3
--- /dev/null
+++ b/packages/fmlrunner/src/codesystem-service.ts
@@ -0,0 +1,265 @@
+import { CodeSystem } from './types';
+
+/**
+ * Service for managing CodeSystem resources
+ */
+export class CodeSystemService {
+ private codeSystems: Map = new Map();
+
+ /**
+ * Register a CodeSystem resource
+ */
+ registerCodeSystem(codeSystem: CodeSystem): void {
+ if (codeSystem.id) {
+ this.codeSystems.set(codeSystem.id, codeSystem);
+ }
+ if (codeSystem.url) {
+ this.codeSystems.set(codeSystem.url, codeSystem);
+ }
+ }
+
+ /**
+ * Get CodeSystem by ID or URL
+ */
+ getCodeSystem(reference: string): CodeSystem | null {
+ return this.codeSystems.get(reference) || null;
+ }
+
+ /**
+ * Get all CodeSystems
+ */
+ getAllCodeSystems(): CodeSystem[] {
+ const unique = new Map();
+ this.codeSystems.forEach((codeSystem) => {
+ const key = codeSystem.id || codeSystem.url || Math.random().toString();
+ unique.set(key, codeSystem);
+ });
+ return Array.from(unique.values());
+ }
+
+ /**
+ * Search CodeSystems by parameters
+ */
+ searchCodeSystems(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ system?: string;
+ publisher?: string;
+ content?: string;
+ }): CodeSystem[] {
+ let results = this.getAllCodeSystems();
+
+ if (params.name) {
+ results = results.filter(cs =>
+ cs.name?.toLowerCase().includes(params.name!.toLowerCase()) ||
+ cs.title?.toLowerCase().includes(params.name!.toLowerCase())
+ );
+ }
+
+ if (params.status) {
+ results = results.filter(cs => cs.status === params.status);
+ }
+
+ if (params.url || params.system) {
+ const searchUrl = params.url || params.system;
+ results = results.filter(cs => cs.url === searchUrl);
+ }
+
+ if (params.publisher) {
+ results = results.filter(cs =>
+ cs.publisher?.toLowerCase().includes(params.publisher!.toLowerCase())
+ );
+ }
+
+ if (params.content) {
+ results = results.filter(cs => cs.content === params.content);
+ }
+
+ return results;
+ }
+
+ /**
+ * Remove CodeSystem by ID or URL
+ */
+ removeCodeSystem(reference: string): boolean {
+ const codeSystem = this.codeSystems.get(reference);
+ if (codeSystem) {
+ // Remove by both ID and URL if present
+ if (codeSystem.id) {
+ this.codeSystems.delete(codeSystem.id);
+ }
+ if (codeSystem.url) {
+ this.codeSystems.delete(codeSystem.url);
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Validate a code in a CodeSystem
+ */
+ validateCode(
+ systemRef: string,
+ code: string,
+ display?: string
+ ): { result: boolean; display?: string; message?: string } {
+ const codeSystem = this.getCodeSystem(systemRef);
+ if (!codeSystem) {
+ return { result: false, message: `CodeSystem not found: ${systemRef}` };
+ }
+
+ if (!codeSystem.concept) {
+ // If no concepts defined, assume code is valid if CodeSystem exists
+ return { result: true, message: 'CodeSystem contains no concept definitions' };
+ }
+
+ const found = this.findConcept(codeSystem.concept, code);
+ if (found) {
+ if (display && found.display && found.display !== display) {
+ return {
+ result: false,
+ message: `Display mismatch. Expected: ${found.display}, got: ${display}`
+ };
+ }
+ return { result: true, display: found.display };
+ }
+
+ return { result: false, message: `Code not found in CodeSystem: ${code}` };
+ }
+
+ /**
+ * Helper method to recursively search concepts
+ */
+ private findConcept(concepts: any[], code: string): any | null {
+ for (const concept of concepts) {
+ if (concept.code === code) {
+ return concept;
+ }
+ // Search nested concepts
+ if (concept.concept) {
+ const found = this.findConcept(concept.concept, code);
+ if (found) return found;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Get concept definition from CodeSystem
+ */
+ lookup(
+ systemRef: string,
+ code: string,
+ property?: string[]
+ ): {
+ name?: string;
+ display?: string;
+ definition?: string;
+ designation?: any[];
+ property?: any[];
+ } | null {
+ const codeSystem = this.getCodeSystem(systemRef);
+ if (!codeSystem?.concept) {
+ return null;
+ }
+
+ const concept = this.findConcept(codeSystem.concept, code);
+ if (!concept) {
+ return null;
+ }
+
+ const result: any = {
+ name: codeSystem.name,
+ display: concept.display,
+ definition: concept.definition
+ };
+
+ if (concept.designation) {
+ result.designation = concept.designation;
+ }
+
+ if (concept.property && property) {
+ result.property = concept.property.filter((p: any) =>
+ property.includes(p.code)
+ );
+ } else if (concept.property) {
+ result.property = concept.property;
+ }
+
+ return result;
+ }
+
+ /**
+ * Subsumption testing (basic implementation)
+ */
+ subsumes(
+ systemRef: string,
+ codeA: string,
+ codeB: string
+ ): 'equivalent' | 'subsumes' | 'subsumed-by' | 'not-subsumed' {
+ const codeSystem = this.getCodeSystem(systemRef);
+ if (!codeSystem?.concept) {
+ return 'not-subsumed';
+ }
+
+ if (codeA === codeB) {
+ return 'equivalent';
+ }
+
+ // Basic implementation - would need hierarchy traversal for full support
+ const conceptA = this.findConcept(codeSystem.concept, codeA);
+ const conceptB = this.findConcept(codeSystem.concept, codeB);
+
+ if (!conceptA || !conceptB) {
+ return 'not-subsumed';
+ }
+
+ // Check if B is a child of A
+ if (this.isChildOf(conceptA, codeB)) {
+ return 'subsumes';
+ }
+
+ // Check if A is a child of B
+ if (this.isChildOf(conceptB, codeA)) {
+ return 'subsumed-by';
+ }
+
+ return 'not-subsumed';
+ }
+
+ /**
+ * Helper to check if a concept has a child with the given code
+ */
+ private isChildOf(concept: any, code: string): boolean {
+ if (!concept.concept) {
+ return false;
+ }
+
+ for (const child of concept.concept) {
+ if (child.code === code) {
+ return true;
+ }
+ if (this.isChildOf(child, code)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Clear all CodeSystems
+ */
+ clear(): void {
+ this.codeSystems.clear();
+ }
+
+ /**
+ * Get count of registered CodeSystems
+ */
+ getCount(): number {
+ return this.getAllCodeSystems().length;
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/conceptmap-service.ts b/packages/fmlrunner/src/conceptmap-service.ts
new file mode 100644
index 0000000..f148fb5
--- /dev/null
+++ b/packages/fmlrunner/src/conceptmap-service.ts
@@ -0,0 +1,154 @@
+import { ConceptMap } from './types';
+
+/**
+ * Service for managing ConceptMap resources
+ */
+export class ConceptMapService {
+ private conceptMaps: Map = new Map();
+
+ /**
+ * Register a ConceptMap resource
+ */
+ registerConceptMap(conceptMap: ConceptMap): void {
+ if (conceptMap.id) {
+ this.conceptMaps.set(conceptMap.id, conceptMap);
+ }
+ if (conceptMap.url) {
+ this.conceptMaps.set(conceptMap.url, conceptMap);
+ }
+ }
+
+ /**
+ * Get ConceptMap by ID or URL
+ */
+ getConceptMap(reference: string): ConceptMap | null {
+ return this.conceptMaps.get(reference) || null;
+ }
+
+ /**
+ * Get all ConceptMaps
+ */
+ getAllConceptMaps(): ConceptMap[] {
+ const unique = new Map();
+ this.conceptMaps.forEach((conceptMap) => {
+ const key = conceptMap.id || conceptMap.url || Math.random().toString();
+ unique.set(key, conceptMap);
+ });
+ return Array.from(unique.values());
+ }
+
+ /**
+ * Search ConceptMaps by parameters
+ */
+ searchConceptMaps(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ source?: string;
+ target?: string;
+ }): ConceptMap[] {
+ let results = this.getAllConceptMaps();
+
+ if (params.name) {
+ results = results.filter(cm =>
+ cm.name?.toLowerCase().includes(params.name!.toLowerCase())
+ );
+ }
+
+ if (params.status) {
+ results = results.filter(cm => cm.status === params.status);
+ }
+
+ if (params.url) {
+ results = results.filter(cm => cm.url === params.url);
+ }
+
+ if (params.source) {
+ results = results.filter(cm =>
+ cm.sourceUri === params.source || cm.sourceCanonical === params.source
+ );
+ }
+
+ if (params.target) {
+ results = results.filter(cm =>
+ cm.targetUri === params.target || cm.targetCanonical === params.target
+ );
+ }
+
+ return results;
+ }
+
+ /**
+ * Remove ConceptMap by ID or URL
+ */
+ removeConceptMap(reference: string): boolean {
+ const conceptMap = this.conceptMaps.get(reference);
+ if (conceptMap) {
+ // Remove by both ID and URL if present
+ if (conceptMap.id) {
+ this.conceptMaps.delete(conceptMap.id);
+ }
+ if (conceptMap.url) {
+ this.conceptMaps.delete(conceptMap.url);
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Translate a code using ConceptMaps
+ */
+ translate(
+ sourceSystem: string,
+ sourceCode: string,
+ targetSystem?: string
+ ): Array<{ system?: string; code?: string; display?: string; equivalence: string }> {
+ const results: Array<{ system?: string; code?: string; display?: string; equivalence: string }> = [];
+
+ // Find relevant ConceptMaps
+ const relevantMaps = this.getAllConceptMaps().filter(cm => {
+ const sourceMatch = cm.sourceUri === sourceSystem || cm.sourceCanonical === sourceSystem;
+ const targetMatch = !targetSystem || cm.targetUri === targetSystem || cm.targetCanonical === targetSystem;
+ return sourceMatch && targetMatch;
+ });
+
+ // Search for translations
+ for (const conceptMap of relevantMaps) {
+ if (conceptMap.group) {
+ for (const group of conceptMap.group) {
+ if (group.source === sourceSystem || !group.source) {
+ for (const element of group.element) {
+ if (element.code === sourceCode && element.target) {
+ for (const target of element.target) {
+ results.push({
+ system: group.target,
+ code: target.code,
+ display: target.display,
+ equivalence: target.equivalence
+ });
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return results;
+ }
+
+ /**
+ * Clear all ConceptMaps
+ */
+ clear(): void {
+ this.conceptMaps.clear();
+ }
+
+ /**
+ * Get count of registered ConceptMaps
+ */
+ getCount(): number {
+ return this.getAllConceptMaps().length;
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/fml-compiler.ts b/packages/fmlrunner/src/fml-compiler.ts
new file mode 100644
index 0000000..ada8150
--- /dev/null
+++ b/packages/fmlrunner/src/fml-compiler.ts
@@ -0,0 +1,735 @@
+import { StructureMap, FmlCompilationResult, StructureMapGroup, StructureMapGroupInput, StructureMapGroupRule, StructureMapGroupRuleSource, StructureMapGroupRuleTarget } from './types';
+
+/**
+ * FML Token types based on FHIR Mapping Language specification
+ */
+enum TokenType {
+ // Keywords
+ MAP = 'MAP',
+ USES = 'USES',
+ IMPORTS = 'IMPORTS',
+ CONCEPTMAP = 'CONCEPTMAP',
+ PREFIX = 'PREFIX',
+ GROUP = 'GROUP',
+ INPUT = 'INPUT',
+ RULE = 'RULE',
+ WHERE = 'WHERE',
+ CHECK = 'CHECK',
+ LOG = 'LOG',
+ AS = 'AS',
+ ALIAS = 'ALIAS',
+ MODE = 'MODE',
+
+ // Identifiers and literals
+ IDENTIFIER = 'IDENTIFIER',
+ STRING = 'STRING',
+ NUMBER = 'NUMBER',
+ CONSTANT = 'CONSTANT',
+
+ // Operators and symbols
+ ARROW = '->',
+ COLON = ':',
+ SEMICOLON = ';',
+ COMMA = ',',
+ DOT = '.',
+ EQUALS = '=',
+ LPAREN = '(',
+ RPAREN = ')',
+ LBRACE = '{',
+ RBRACE = '}',
+ LBRACKET = '[',
+ RBRACKET = ']',
+
+ // Special
+ NEWLINE = 'NEWLINE',
+ EOF = 'EOF',
+ WHITESPACE = 'WHITESPACE',
+ COMMENT = 'COMMENT'
+}
+
+/**
+ * FML Token
+ */
+interface Token {
+ type: TokenType;
+ value: string;
+ line: number;
+ column: number;
+}
+
+/**
+ * FML Tokenizer for FHIR Mapping Language
+ */
+class FmlTokenizer {
+ private input: string;
+ private position: number = 0;
+ private line: number = 1;
+ private column: number = 1;
+
+ constructor(input: string) {
+ this.input = input;
+ }
+
+ /**
+ * Tokenize the input string
+ */
+ tokenize(): Token[] {
+ const tokens: Token[] = [];
+
+ // Skip initial whitespace and newlines
+ while (!this.isAtEnd() && (this.isWhitespace(this.peek()) || this.peek() === '\n')) {
+ this.advance();
+ }
+
+ while (!this.isAtEnd()) {
+ const token = this.nextToken();
+ if (token && token.type !== TokenType.WHITESPACE && token.type !== TokenType.COMMENT && token.type !== TokenType.NEWLINE) {
+ tokens.push(token);
+ }
+ }
+
+ tokens.push({
+ type: TokenType.EOF,
+ value: '',
+ line: this.line,
+ column: this.column
+ });
+
+ return tokens;
+ }
+
+ private nextToken(): Token | null {
+ if (this.isAtEnd()) return null;
+
+ const start = this.position;
+ const startLine = this.line;
+ const startColumn = this.column;
+ const char = this.advance();
+
+ // Skip whitespace
+ if (this.isWhitespace(char)) {
+ while (!this.isAtEnd() && this.isWhitespace(this.peek())) {
+ this.advance();
+ }
+ return {
+ type: TokenType.WHITESPACE,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle newlines
+ if (char === '\n') {
+ return {
+ type: TokenType.NEWLINE,
+ value: char,
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle comments
+ if (char === '/') {
+ if (this.peek() === '/') {
+ // Single-line comment or documentation comment
+ if (this.position + 1 < this.input.length && this.input.charAt(this.position + 1) === '/') {
+ // Documentation comment: ///
+ this.advance(); // Skip second /
+ while (!this.isAtEnd() && this.peek() !== '\n') {
+ this.advance();
+ }
+ return {
+ type: TokenType.COMMENT,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ } else {
+ // Regular single-line comment: //
+ while (!this.isAtEnd() && this.peek() !== '\n') {
+ this.advance();
+ }
+ return {
+ type: TokenType.COMMENT,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ }
+ } else if (this.peek() === '*') {
+ // Multi-line comment: /* ... */
+ this.advance(); // Skip *
+ while (!this.isAtEnd()) {
+ if (this.peek() === '*' && this.position + 1 < this.input.length && this.input.charAt(this.position + 1) === '/') {
+ this.advance(); // Skip *
+ this.advance(); // Skip /
+ break;
+ }
+ this.advance();
+ }
+ return {
+ type: TokenType.COMMENT,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ }
+ }
+
+ // Handle strings
+ if (char === '"' || char === "'") {
+ const quote = char;
+ while (!this.isAtEnd() && this.peek() !== quote) {
+ if (this.peek() === '\\') this.advance(); // Skip escaped characters
+ this.advance();
+ }
+ if (!this.isAtEnd()) this.advance(); // Closing quote
+
+ return {
+ type: TokenType.STRING,
+ value: this.input.substring(start + 1, this.position - 1), // Remove quotes
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle numbers
+ if (this.isDigit(char)) {
+ while (!this.isAtEnd() && (this.isDigit(this.peek()) || this.peek() === '.')) {
+ this.advance();
+ }
+ return {
+ type: TokenType.NUMBER,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle identifiers and keywords
+ if (this.isAlpha(char) || char === '_') {
+ while (!this.isAtEnd() && (this.isAlphaNumeric(this.peek()) || this.peek() === '_')) {
+ this.advance();
+ }
+
+ const value = this.input.substring(start, this.position);
+ const type = this.getKeywordType(value.toUpperCase()) || TokenType.IDENTIFIER;
+
+ return {
+ type,
+ value,
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle operators and symbols
+ switch (char) {
+ case '-':
+ if (this.peek() === '>') {
+ this.advance();
+ return { type: TokenType.ARROW, value: '->', line: startLine, column: startColumn };
+ }
+ break;
+ case ':': return { type: TokenType.COLON, value: char, line: startLine, column: startColumn };
+ case ';': return { type: TokenType.SEMICOLON, value: char, line: startLine, column: startColumn };
+ case ',': return { type: TokenType.COMMA, value: char, line: startLine, column: startColumn };
+ case '.': return { type: TokenType.DOT, value: char, line: startLine, column: startColumn };
+ case '=': return { type: TokenType.EQUALS, value: char, line: startLine, column: startColumn };
+ case '(': return { type: TokenType.LPAREN, value: char, line: startLine, column: startColumn };
+ case ')': return { type: TokenType.RPAREN, value: char, line: startLine, column: startColumn };
+ case '{': return { type: TokenType.LBRACE, value: char, line: startLine, column: startColumn };
+ case '}': return { type: TokenType.RBRACE, value: char, line: startLine, column: startColumn };
+ case '[': return { type: TokenType.LBRACKET, value: char, line: startLine, column: startColumn };
+ case ']': return { type: TokenType.RBRACKET, value: char, line: startLine, column: startColumn };
+ }
+
+ throw new Error(`Unexpected character '${char}' at line ${startLine}, column ${startColumn}`);
+ }
+
+ private getKeywordType(keyword: string): TokenType | null {
+ const keywords: { [key: string]: TokenType } = {
+ 'MAP': TokenType.MAP,
+ 'USES': TokenType.USES,
+ 'IMPORTS': TokenType.IMPORTS,
+ 'CONCEPTMAP': TokenType.CONCEPTMAP,
+ 'PREFIX': TokenType.PREFIX,
+ 'GROUP': TokenType.GROUP,
+ 'INPUT': TokenType.INPUT,
+ 'RULE': TokenType.RULE,
+ 'WHERE': TokenType.WHERE,
+ 'CHECK': TokenType.CHECK,
+ 'LOG': TokenType.LOG,
+ 'AS': TokenType.AS,
+ 'ALIAS': TokenType.ALIAS,
+ 'MODE': TokenType.MODE
+ };
+
+ return keywords[keyword] || null;
+ }
+
+ private isAtEnd(): boolean {
+ return this.position >= this.input.length;
+ }
+
+ private advance(): string {
+ const char = this.input.charAt(this.position++);
+ if (char === '\n') {
+ this.line++;
+ this.column = 1;
+ } else {
+ this.column++;
+ }
+ return char;
+ }
+
+ private peek(): string {
+ if (this.isAtEnd()) return '\0';
+ return this.input.charAt(this.position);
+ }
+
+ private isWhitespace(char: string): boolean {
+ return char === ' ' || char === '\t' || char === '\r';
+ }
+
+ private isDigit(char: string): boolean {
+ return char >= '0' && char <= '9';
+ }
+
+ private isAlpha(char: string): boolean {
+ return (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z');
+ }
+
+ private isAlphaNumeric(char: string): boolean {
+ return this.isAlpha(char) || this.isDigit(char);
+ }
+}
+
+/**
+ * FML Parser for FHIR Mapping Language
+ */
+class FmlParser {
+ private tokens: Token[];
+ private current: number = 0;
+
+ constructor(tokens: Token[]) {
+ this.tokens = tokens;
+ }
+
+ /**
+ * Parse tokens into a StructureMap
+ */
+ parse(): StructureMap {
+ try {
+ return this.parseMap();
+ } catch (error) {
+ // If parsing fails, try partial parsing to extract what we can
+ return this.attemptPartialParse();
+ }
+ }
+
+ private attemptPartialParse(): StructureMap {
+ // Reset to beginning
+ this.current = 0;
+
+ // Try to extract basic map info even if full parsing fails
+ let url = 'http://example.org/StructureMap/DefaultMap';
+ let name = 'DefaultMap';
+
+ // Look for map declaration anywhere in the token stream
+ while (this.current < this.tokens.length - 1) {
+ if (this.tokens[this.current].type === TokenType.MAP) {
+ try {
+ this.current++; // Skip MAP token
+ if (this.current < this.tokens.length && this.tokens[this.current].type === TokenType.STRING) {
+ url = this.tokens[this.current].value;
+ this.current++;
+ if (this.current < this.tokens.length && this.tokens[this.current].type === TokenType.EQUALS) {
+ this.current++;
+ if (this.current < this.tokens.length && this.tokens[this.current].type === TokenType.STRING) {
+ name = this.tokens[this.current].value;
+ break;
+ }
+ }
+ }
+ } catch (error) {
+ // Continue looking
+ }
+ }
+ this.current++;
+ }
+
+ return this.createFallbackStructureMap(url, name);
+ }
+
+ private createFallbackStructureMap(url?: string, name?: string): StructureMap {
+ // Create a basic StructureMap for cases where parsing fails
+ return {
+ resourceType: 'StructureMap',
+ url: url || 'http://example.org/StructureMap/DefaultMap',
+ name: name || 'DefaultMap',
+ status: 'draft',
+ group: [{
+ name: 'main',
+ input: [
+ { name: 'source', mode: 'source' as 'source' },
+ { name: 'target', mode: 'target' as 'target' }
+ ],
+ rule: []
+ }]
+ };
+ }
+
+ private parseMap(): StructureMap {
+ let url = 'http://example.org/StructureMap/DefaultMap';
+ let name = 'DefaultMap';
+
+ // Check if there's a map declaration at the beginning
+ if (this.check(TokenType.MAP)) {
+ // Parse map declaration: map "url" = "name"
+ this.consume(TokenType.MAP, "Expected 'map' keyword");
+
+ url = this.consume(TokenType.STRING, "Expected URL string after 'map'").value;
+ this.consume(TokenType.EQUALS, "Expected '=' after map URL");
+ name = this.consume(TokenType.STRING, "Expected name string after '='").value;
+ }
+
+ const structureMap: StructureMap = {
+ resourceType: 'StructureMap',
+ url,
+ name,
+ status: 'draft',
+ group: []
+ };
+
+ // Parse optional uses statements
+ while (this.match(TokenType.USES)) {
+ this.parseUses();
+ }
+
+ // Parse optional imports statements
+ while (this.match(TokenType.IMPORTS)) {
+ this.parseImports();
+ }
+
+ // Parse optional prefix declarations
+ while (this.match(TokenType.PREFIX)) {
+ this.parsePrefix();
+ }
+
+ // Parse optional conceptmap declarations
+ while (this.match(TokenType.CONCEPTMAP)) {
+ this.parseConceptMap();
+ }
+
+ // Parse groups
+ while (this.match(TokenType.GROUP)) {
+ const group = this.parseGroup();
+ structureMap.group.push(group);
+ }
+
+ // If no groups were defined, create a default one and parse any remaining rules
+ if (structureMap.group.length === 0) {
+ const defaultGroup: StructureMapGroup = {
+ name: 'main',
+ input: [
+ { name: 'source', mode: 'source' as 'source' },
+ { name: 'target', mode: 'target' as 'target' }
+ ],
+ rule: []
+ };
+
+ // Parse any remaining rules at the top level
+ while (!this.isAtEnd()) {
+ if (this.check(TokenType.IDENTIFIER)) {
+ // Try to parse as a rule
+ try {
+ const rule = this.parseRule();
+ if (rule) {
+ defaultGroup.rule.push(rule as StructureMapGroupRule);
+ }
+ } catch (error) {
+ // Skip malformed rules
+ this.advance();
+ }
+ } else {
+ this.advance(); // Skip unexpected tokens
+ }
+ }
+
+ structureMap.group.push(defaultGroup);
+ }
+
+ return structureMap;
+ }
+
+ private parseUses(): void {
+ // uses "url" alias name as mode
+ const url = this.consume(TokenType.STRING, "Expected URL after 'uses'").value;
+
+ // Check if there's an alias keyword
+ if (this.match(TokenType.ALIAS)) {
+ const alias = this.consume(TokenType.IDENTIFIER, "Expected alias name after 'alias'").value;
+ this.consume(TokenType.AS, "Expected 'as' after alias name");
+ const mode = this.consume(TokenType.IDENTIFIER, "Expected mode after 'as'").value;
+ // TODO: Store uses information in StructureMap
+ }
+ }
+
+ private parseImports(): void {
+ // imports "url"
+ const url = this.consume(TokenType.STRING, "Expected URL after 'imports'").value;
+ // TODO: Store imports information in StructureMap
+ }
+
+ private parsePrefix(): void {
+ // prefix system = "url"
+ const prefix = this.consume(TokenType.IDENTIFIER, "Expected prefix name after 'prefix'").value;
+ this.consume(TokenType.EQUALS, "Expected '=' after prefix name");
+ const url = this.consume(TokenType.STRING, "Expected URL after '='").value;
+ // TODO: Store prefix information in StructureMap
+ }
+
+ private parseConceptMap(): void {
+ // conceptmap "url" { ... }
+ const url = this.consume(TokenType.STRING, "Expected URL after 'conceptmap'").value;
+ this.consume(TokenType.LBRACE, "Expected '{' after conceptmap URL");
+
+ // Skip content inside braces for now - conceptmap parsing is complex
+ let braceCount = 1;
+ while (!this.isAtEnd() && braceCount > 0) {
+ if (this.check(TokenType.LBRACE)) {
+ braceCount++;
+ } else if (this.check(TokenType.RBRACE)) {
+ braceCount--;
+ }
+ this.advance();
+ }
+ // TODO: Store conceptmap information in StructureMap
+ }
+
+ private parseGroup(): StructureMapGroup {
+ const name = this.consume(TokenType.IDENTIFIER, "Expected group name").value;
+ this.consume(TokenType.LPAREN, "Expected '(' after group name");
+
+ const inputs: StructureMapGroupInput[] = [];
+
+ // Parse input parameters
+ if (!this.check(TokenType.RPAREN)) {
+ do {
+ const input = this.parseInput();
+ inputs.push(input);
+ } while (this.match(TokenType.COMMA));
+ }
+
+ this.consume(TokenType.RPAREN, "Expected ')' after group inputs");
+
+ const rules: StructureMapGroupRule[] = [];
+
+ // Parse rules
+ while (!this.isAtEnd() && !this.check(TokenType.GROUP)) {
+ if (this.match(TokenType.IDENTIFIER)) {
+ // This is likely a rule - backup and parse it
+ this.current--;
+ const rule = this.parseRule();
+ if (rule) {
+ rules.push(rule);
+ }
+ } else {
+ this.advance(); // Skip unexpected tokens
+ }
+ }
+
+ return {
+ name,
+ input: inputs,
+ rule: rules
+ };
+ }
+
+ private parseInput(): StructureMapGroupInput {
+ // Parse: mode name : type
+ const firstToken = this.consume(TokenType.IDENTIFIER, "Expected mode or name").value;
+
+ // Check if this is mode name : type pattern
+ if (this.check(TokenType.IDENTIFIER)) {
+ // First token is mode, second is name
+ const mode = firstToken as 'source' | 'target';
+ const name = this.consume(TokenType.IDENTIFIER, "Expected input name").value;
+ this.consume(TokenType.COLON, "Expected ':' after input name");
+ const type = this.consume(TokenType.IDENTIFIER, "Expected input type").value;
+
+ return {
+ name,
+ type,
+ mode: (mode === 'source' || mode === 'target') ? mode : 'source'
+ };
+ } else {
+ // Original pattern: name : type [as mode]
+ const name = firstToken;
+ this.consume(TokenType.COLON, "Expected ':' after input name");
+ const type = this.consume(TokenType.IDENTIFIER, "Expected input type").value;
+
+ let mode: 'source' | 'target' = 'source'; // default
+ if (this.match(TokenType.AS)) {
+ const modeValue = this.consume(TokenType.IDENTIFIER, "Expected mode after 'as'").value;
+ if (modeValue === 'source' || modeValue === 'target') {
+ mode = modeValue;
+ }
+ }
+
+ return {
+ name,
+ type,
+ mode
+ };
+ }
+ }
+
+ private parseRule(): StructureMapGroupRule {
+ const name = this.consume(TokenType.IDENTIFIER, "Expected rule name").value;
+ this.consume(TokenType.COLON, "Expected ':' after rule name");
+
+ const sources: StructureMapGroupRuleSource[] = [];
+ const targets: StructureMapGroupRuleTarget[] = [];
+
+ // Parse source expressions
+ do {
+ const source = this.parseExpression();
+ sources.push(source as StructureMapGroupRuleSource);
+ } while (this.match(TokenType.COMMA));
+
+ this.consume(TokenType.ARROW, "Expected '->' in rule");
+
+ // Parse target expressions
+ do {
+ const target = this.parseExpression();
+ targets.push(target as StructureMapGroupRuleTarget);
+ } while (this.match(TokenType.COMMA));
+
+ // Optional semicolon
+ this.match(TokenType.SEMICOLON);
+
+ return {
+ name,
+ source: sources,
+ target: targets
+ };
+ }
+
+ private parseExpression(): any {
+ let context = 'source';
+ let element = '';
+
+ if (this.check(TokenType.IDENTIFIER)) {
+ const token = this.advance();
+ context = token.value;
+
+ if (this.match(TokenType.DOT)) {
+ element = this.consume(TokenType.IDENTIFIER, "Expected element name after '.'").value;
+ }
+ }
+
+ return {
+ context,
+ element
+ };
+ }
+
+ // Utility methods
+ private match(...types: TokenType[]): boolean {
+ for (const type of types) {
+ if (this.check(type)) {
+ this.advance();
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private check(type: TokenType): boolean {
+ if (this.isAtEnd()) return false;
+ return this.peek().type === type;
+ }
+
+ private advance(): Token {
+ if (!this.isAtEnd()) this.current++;
+ return this.previous();
+ }
+
+ private isAtEnd(): boolean {
+ return this.current >= this.tokens.length || this.peek().type === TokenType.EOF;
+ }
+
+ private peek(): Token {
+ if (this.current >= this.tokens.length) {
+ return { type: TokenType.EOF, value: '', line: 0, column: 0 };
+ }
+ return this.tokens[this.current];
+ }
+
+ private previous(): Token {
+ return this.tokens[this.current - 1];
+ }
+
+ private consume(type: TokenType, message: string): Token {
+ if (this.check(type)) return this.advance();
+
+ const current = this.peek();
+ throw new Error(`${message}. Got ${current.type} '${current.value}' at line ${current.line}, column ${current.column}`);
+ }
+}
+
+/**
+ * Enhanced FML Compiler with proper tokenization and grammar handling
+ */
+export class FmlCompiler {
+
+ /**
+ * Compile FML content to a StructureMap using proper parsing
+ * @param fmlContent The FML content to compile
+ * @returns Compilation result with StructureMap or errors
+ */
+ compile(fmlContent: string): FmlCompilationResult {
+ try {
+ // Basic validation
+ if (!fmlContent || fmlContent.trim().length === 0) {
+ return {
+ success: false,
+ errors: ['FML content cannot be empty']
+ };
+ }
+
+ // Tokenize the FML content
+ const tokenizer = new FmlTokenizer(fmlContent);
+ const tokens = tokenizer.tokenize();
+
+ // Parse tokens into StructureMap
+ const parser = new FmlParser(tokens);
+ const structureMap = parser.parse();
+
+ return {
+ success: true,
+ structureMap
+ };
+ } catch (error) {
+ return {
+ success: false,
+ errors: [error instanceof Error ? error.message : 'Unknown compilation error']
+ };
+ }
+ }
+
+ /**
+ * Legacy method for backwards compatibility - now uses the new parser
+ * @deprecated Use compile() method instead
+ */
+ parseFmlToStructureMap(fmlContent: string): StructureMap {
+ const result = this.compile(fmlContent);
+ if (result.success && result.structureMap) {
+ return result.structureMap;
+ }
+ throw new Error(result.errors?.join(', ') || 'Compilation failed');
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/index.ts b/packages/fmlrunner/src/index.ts
new file mode 100644
index 0000000..ff3abd4
--- /dev/null
+++ b/packages/fmlrunner/src/index.ts
@@ -0,0 +1,699 @@
+import { FmlCompiler } from './lib/fml-compiler';
+import { StructureMapRetriever } from './lib/structure-map-retriever';
+import { StructureMapExecutor } from './lib/structure-map-executor';
+import { ValidationService } from './lib/validation-service';
+import { ConceptMapService } from './lib/conceptmap-service';
+import { ValueSetService } from './lib/valueset-service';
+import { CodeSystemService } from './lib/codesystem-service';
+import { BundleService, BundleProcessingResult } from './lib/bundle-service';
+import { Logger } from './lib/logger';
+import { SchemaValidator } from './lib/schema-validator';
+import {
+ StructureMap,
+ FmlCompilationResult,
+ ExecutionResult,
+ EnhancedExecutionResult,
+ ExecutionOptions,
+ FmlRunnerOptions,
+ StructureDefinition,
+ ConceptMap,
+ ValueSet,
+ CodeSystem,
+ Bundle
+} from './types';
+
+/**
+ * Main FmlRunner class providing FML compilation and StructureMap execution
+ * with JSON schema validation and comprehensive logging
+ */
+export class FmlRunner {
+ private compiler: FmlCompiler;
+ private retriever: StructureMapRetriever;
+ private executor: StructureMapExecutor;
+ private conceptMapService: ConceptMapService;
+ private valueSetService: ValueSetService;
+ private codeSystemService: CodeSystemService;
+ private bundleService: BundleService;
+ private schemaValidator: SchemaValidator;
+ private logger: Logger;
+ private structureMapStore: Map = new Map();
+ private options: FmlRunnerOptions;
+
+ constructor(options: FmlRunnerOptions = {}) {
+ this.options = {
+ cacheEnabled: true,
+ timeout: 5000,
+ strictMode: false,
+ validateInputOutput: true,
+ ...options
+ };
+
+ this.logger = new Logger('FmlRunner', this.options.logLevel);
+ this.schemaValidator = new SchemaValidator(this.logger);
+
+ this.compiler = new FmlCompiler(this.logger);
+ this.retriever = new StructureMapRetriever(this.logger);
+ this.executor = new StructureMapExecutor(this.logger);
+ this.conceptMapService = new ConceptMapService(this.logger);
+ this.valueSetService = new ValueSetService(this.logger);
+ this.codeSystemService = new CodeSystemService(this.logger);
+
+ // Create bundle service with references to all resource services
+ this.bundleService = new BundleService(
+ this.conceptMapService,
+ this.valueSetService,
+ this.codeSystemService,
+ this.executor.getValidationService(),
+ this.structureMapStore,
+ this.logger
+ );
+
+ // Set base URL for retriever if provided
+ if (options.baseUrl) {
+ this.retriever.setBaseDirectory(options.baseUrl);
+ }
+
+ // Enhance executor with terminology services
+ this.executor.setTerminologyServices(
+ this.conceptMapService,
+ this.valueSetService,
+ this.codeSystemService
+ );
+
+ this.logger.info('FmlRunner initialized', { options: this.options });
+ }
+
+ /**
+ * Compile FML content to StructureMap with input validation
+ */
+ compileFml(fmlContent: string): FmlCompilationResult {
+ this.logger.debug('Compiling FML content', { contentLength: fmlContent.length });
+
+ if (this.options.validateInputOutput) {
+ const validation = this.schemaValidator.validateFmlInput(fmlContent);
+ if (!validation.valid) {
+ this.logger.error('FML input validation failed', { errors: validation.errors });
+ return {
+ success: false,
+ errors: validation.errors
+ };
+ }
+ }
+
+ const result = this.compiler.compile(fmlContent);
+
+ if (this.options.validateInputOutput && result.success && result.structureMap) {
+ const validation = this.schemaValidator.validateStructureMapOutput(result.structureMap);
+ if (!validation.valid) {
+ this.logger.error('StructureMap output validation failed', { errors: validation.errors });
+ return {
+ success: false,
+ errors: validation.errors
+ };
+ }
+ }
+
+ this.logger.info('FML compilation completed', {
+ success: result.success,
+ errorCount: result.errors?.length || 0
+ });
+
+ return result;
+ }
+
+ /**
+ * Execute StructureMap on input content with validation
+ */
+ async executeStructureMap(structureMapReference: string, inputContent: any): Promise {
+ this.logger.debug('Executing StructureMap', { reference: structureMapReference });
+
+ if (this.options.validateInputOutput) {
+ const validation = this.schemaValidator.validateExecutionInput(inputContent);
+ if (!validation.valid) {
+ this.logger.error('Execution input validation failed', { errors: validation.errors });
+ return {
+ success: false,
+ errors: validation.errors
+ };
+ }
+ }
+
+ try {
+ // Retrieve the StructureMap
+ const structureMap = await this.retriever.getStructureMap(structureMapReference);
+
+ if (!structureMap) {
+ const error = `StructureMap not found: ${structureMapReference}`;
+ this.logger.error(error);
+ return {
+ success: false,
+ errors: [error]
+ };
+ }
+
+ // Validate the StructureMap
+ const validation = this.executor.validateStructureMap(structureMap);
+ if (!validation.valid) {
+ const error = `Invalid StructureMap: ${validation.errors.join(', ')}`;
+ this.logger.error(error);
+ return {
+ success: false,
+ errors: [error]
+ };
+ }
+
+ // Execute the transformation
+ const result = this.executor.execute(structureMap, inputContent);
+
+ if (this.options.validateInputOutput && result.success && result.result) {
+ const validation = this.schemaValidator.validateExecutionOutput(result.result);
+ if (!validation.valid) {
+ this.logger.error('Execution output validation failed', { errors: validation.errors });
+ return {
+ success: false,
+ errors: validation.errors
+ };
+ }
+ }
+
+ this.logger.info('StructureMap execution completed', {
+ success: result.success,
+ reference: structureMapReference
+ });
+
+ return result;
+ } catch (error) {
+ const errorMessage = error instanceof Error ? error.message : 'Unknown execution error';
+ this.logger.error('StructureMap execution failed', { error: errorMessage });
+ return {
+ success: false,
+ errors: [errorMessage]
+ };
+ }
+ }
+
+ /**
+ * Execute StructureMap with validation support
+ */
+ async executeStructureMapWithValidation(
+ structureMapReference: string,
+ inputContent: any,
+ options?: ExecutionOptions
+ ): Promise {
+ this.logger.debug('Executing StructureMap with validation', {
+ reference: structureMapReference,
+ options
+ });
+
+ try {
+ // Retrieve the StructureMap
+ const structureMap = await this.retriever.getStructureMap(structureMapReference);
+
+ if (!structureMap) {
+ const error = `StructureMap not found: ${structureMapReference}`;
+ this.logger.error(error);
+ return {
+ success: false,
+ errors: [error]
+ };
+ }
+
+ // Validate the StructureMap
+ const validation = this.executor.validateStructureMap(structureMap);
+ if (!validation.valid) {
+ const error = `Invalid StructureMap: ${validation.errors.join(', ')}`;
+ this.logger.error(error);
+ return {
+ success: false,
+ errors: [error]
+ };
+ }
+
+ // Execute the transformation with validation
+ const mergedOptions = {
+ strictMode: this.options.strictMode,
+ ...options
+ };
+
+ const result = this.executor.execute(structureMap, inputContent, mergedOptions);
+
+ this.logger.info('StructureMap execution with validation completed', {
+ success: result.success,
+ reference: structureMapReference
+ });
+
+ return result;
+ } catch (error) {
+ const errorMessage = error instanceof Error ? error.message : 'Unknown execution error';
+ this.logger.error('StructureMap execution with validation failed', { error: errorMessage });
+ return {
+ success: false,
+ errors: [errorMessage]
+ };
+ }
+ }
+
+ /**
+ * Register a StructureDefinition for validation
+ */
+ registerStructureDefinition(structureDefinition: StructureDefinition): void {
+ this.logger.debug('Registering StructureDefinition', { id: structureDefinition.id });
+
+ if (this.options.validateInputOutput && !this.options.disableValidation) {
+ const validation = this.schemaValidator.validateStructureDefinition(structureDefinition);
+ if (!validation.valid) {
+ this.logger.error('StructureDefinition validation failed', { errors: validation.errors });
+ if (this.options.strictMode) {
+ throw new Error(`Invalid StructureDefinition: ${validation.errors.join(', ')}`);
+ }
+ }
+ }
+
+ const validationService = this.executor.getValidationService();
+ validationService.registerStructureDefinition(structureDefinition);
+
+ this.logger.info('StructureDefinition registered', { id: structureDefinition.id });
+ }
+
+ /**
+ * Get the validation service
+ */
+ getValidationService(): ValidationService | null {
+ return this.executor.getValidationService();
+ }
+
+ /**
+ * Retrieve StructureMap by reference
+ */
+ async getStructureMap(reference: string): Promise {
+ this.logger.debug('Retrieving StructureMap', { reference });
+ const result = await this.retriever.getStructureMap(reference);
+ this.logger.debug('StructureMap retrieval completed', {
+ reference,
+ found: !!result
+ });
+ return result;
+ }
+
+ /**
+ * Clear all internal caches
+ */
+ clearCache(): void {
+ this.logger.info('Clearing all caches');
+ this.retriever.clearCache();
+ }
+
+ /**
+ * Set base directory for StructureMap file loading
+ */
+ setBaseDirectory(directory: string): void {
+ this.logger.info('Setting base directory', { directory });
+ this.retriever.setBaseDirectory(directory);
+ }
+
+ // ============================================
+ // LIBRARY API METHODS FOR RESOURCE MANAGEMENT
+ // ============================================
+
+ /**
+ * Process a FHIR Bundle and load all resources
+ */
+ processBundle(bundle: Bundle): BundleProcessingResult {
+ this.logger.info('Processing FHIR Bundle', {
+ entryCount: bundle.entry?.length || 0
+ });
+
+ if (this.options.validateInputOutput && !this.options.disableValidation) {
+ const validation = this.schemaValidator.validateBundle(bundle);
+ if (!validation.valid) {
+ this.logger.error('Bundle validation failed', { errors: validation.errors });
+ if (this.options.strictMode) {
+ return {
+ success: false,
+ errors: validation.errors,
+ warnings: [],
+ processed: {
+ structureMaps: 0,
+ structureDefinitions: 0,
+ conceptMaps: 0,
+ valueSets: 0,
+ codeSystems: 0,
+ other: 0
+ }
+ };
+ }
+ }
+ }
+
+ const result = this.bundleService.processBundle(bundle);
+
+ this.logger.info('Bundle processing completed', {
+ success: result.success,
+ processed: result.processed
+ });
+
+ return result;
+ }
+
+ /**
+ * Get bundle processing statistics
+ */
+ getBundleStats(): {
+ structureMaps: number;
+ structureDefinitions: number;
+ conceptMaps: number;
+ valueSets: number;
+ codeSystems: number;
+ } {
+ return this.bundleService.getStats();
+ }
+
+ /**
+ * Create a summary bundle of all loaded resources
+ */
+ createResourceSummaryBundle(): Bundle {
+ return this.bundleService.createSummaryBundle();
+ }
+
+ /**
+ * Clear all loaded resources
+ */
+ clearAllResources(): void {
+ this.logger.info('Clearing all loaded resources');
+ this.bundleService.clearAll();
+ }
+
+ // ============================================
+ // CONCEPTMAP LIBRARY API METHODS
+ // ============================================
+
+ /**
+ * Register a ConceptMap resource
+ */
+ registerConceptMap(conceptMap: ConceptMap): void {
+ this.logger.debug('Registering ConceptMap', { id: conceptMap.id });
+ this.conceptMapService.registerConceptMap(conceptMap);
+ this.logger.info('ConceptMap registered', { id: conceptMap.id });
+ }
+
+ /**
+ * Get ConceptMap by ID or URL
+ */
+ getConceptMap(reference: string): ConceptMap | null {
+ return this.conceptMapService.getConceptMap(reference);
+ }
+
+ /**
+ * Get all registered ConceptMaps
+ */
+ getAllConceptMaps(): ConceptMap[] {
+ return this.conceptMapService.getAllConceptMaps();
+ }
+
+ /**
+ * Search ConceptMaps by parameters
+ */
+ searchConceptMaps(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ source?: string;
+ target?: string;
+ }): ConceptMap[] {
+ return this.conceptMapService.searchConceptMaps(params);
+ }
+
+ /**
+ * Remove ConceptMap by ID or URL
+ */
+ removeConceptMap(reference: string): boolean {
+ this.logger.debug('Removing ConceptMap', { reference });
+ const result = this.conceptMapService.removeConceptMap(reference);
+ this.logger.info('ConceptMap removal completed', { reference, removed: result });
+ return result;
+ }
+
+ /**
+ * Translate a code using loaded ConceptMaps
+ */
+ translateCode(
+ sourceSystem: string,
+ sourceCode: string,
+ targetSystem?: string
+ ): Array<{ system?: string; code?: string; display?: string; equivalence: string }> {
+ return this.conceptMapService.translate(sourceSystem, sourceCode, targetSystem);
+ }
+
+ // ============================================
+ // VALUESET LIBRARY API METHODS
+ // ============================================
+
+ /**
+ * Register a ValueSet resource
+ */
+ registerValueSet(valueSet: ValueSet): void {
+ this.logger.debug('Registering ValueSet', { id: valueSet.id });
+ this.valueSetService.registerValueSet(valueSet);
+ this.logger.info('ValueSet registered', { id: valueSet.id });
+ }
+
+ /**
+ * Get ValueSet by ID or URL
+ */
+ getValueSet(reference: string): ValueSet | null {
+ return this.valueSetService.getValueSet(reference);
+ }
+
+ /**
+ * Get all registered ValueSets
+ */
+ getAllValueSets(): ValueSet[] {
+ return this.valueSetService.getAllValueSets();
+ }
+
+ /**
+ * Search ValueSets by parameters
+ */
+ searchValueSets(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ publisher?: string;
+ jurisdiction?: string;
+ }): ValueSet[] {
+ return this.valueSetService.searchValueSets(params);
+ }
+
+ /**
+ * Remove ValueSet by ID or URL
+ */
+ removeValueSet(reference: string): boolean {
+ this.logger.debug('Removing ValueSet', { reference });
+ const result = this.valueSetService.removeValueSet(reference);
+ this.logger.info('ValueSet removal completed', { reference, removed: result });
+ return result;
+ }
+
+ /**
+ * Validate a code against a ValueSet
+ */
+ validateCodeInValueSet(
+ valueSetRef: string,
+ system?: string,
+ code?: string,
+ display?: string
+ ): { result: boolean; message?: string } {
+ return this.valueSetService.validateCode(valueSetRef, system, code, display);
+ }
+
+ /**
+ * Expand a ValueSet
+ */
+ expandValueSet(valueSetRef: string, count?: number, offset?: number): ValueSet | null {
+ return this.valueSetService.expand(valueSetRef, count, offset);
+ }
+
+ // ============================================
+ // CODESYSTEM LIBRARY API METHODS
+ // ============================================
+
+ /**
+ * Register a CodeSystem resource
+ */
+ registerCodeSystem(codeSystem: CodeSystem): void {
+ this.logger.debug('Registering CodeSystem', { id: codeSystem.id });
+ this.codeSystemService.registerCodeSystem(codeSystem);
+ this.logger.info('CodeSystem registered', { id: codeSystem.id });
+ }
+
+ /**
+ * Get CodeSystem by ID or URL
+ */
+ getCodeSystem(reference: string): CodeSystem | null {
+ return this.codeSystemService.getCodeSystem(reference);
+ }
+
+ /**
+ * Get all registered CodeSystems
+ */
+ getAllCodeSystems(): CodeSystem[] {
+ return this.codeSystemService.getAllCodeSystems();
+ }
+
+ /**
+ * Search CodeSystems by parameters
+ */
+ searchCodeSystems(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ system?: string;
+ publisher?: string;
+ content?: string;
+ }): CodeSystem[] {
+ return this.codeSystemService.searchCodeSystems(params);
+ }
+
+ /**
+ * Remove CodeSystem by ID or URL
+ */
+ removeCodeSystem(reference: string): boolean {
+ this.logger.debug('Removing CodeSystem', { reference });
+ const result = this.codeSystemService.removeCodeSystem(reference);
+ this.logger.info('CodeSystem removal completed', { reference, removed: result });
+ return result;
+ }
+
+ /**
+ * Validate a code in a CodeSystem
+ */
+ validateCodeInCodeSystem(
+ systemRef: string,
+ code: string,
+ display?: string
+ ): { result: boolean; display?: string; message?: string } {
+ return this.codeSystemService.validateCode(systemRef, code, display);
+ }
+
+ /**
+ * Lookup concept details in a CodeSystem
+ */
+ lookupConcept(
+ systemRef: string,
+ code: string,
+ property?: string[]
+ ): {
+ name?: string;
+ display?: string;
+ definition?: string;
+ designation?: any[];
+ property?: any[];
+ } | null {
+ return this.codeSystemService.lookup(systemRef, code, property);
+ }
+
+ /**
+ * Test subsumption relationship between two codes
+ */
+ testSubsumption(
+ systemRef: string,
+ codeA: string,
+ codeB: string
+ ): 'equivalent' | 'subsumes' | 'subsumed-by' | 'not-subsumed' {
+ return this.codeSystemService.subsumes(systemRef, codeA, codeB);
+ }
+
+ // ============================================
+ // STRUCTUREMAP LIBRARY API METHODS
+ // ============================================
+
+ /**
+ * Register a StructureMap resource
+ */
+ registerStructureMap(structureMap: StructureMap): void {
+ this.logger.debug('Registering StructureMap', { id: structureMap.id });
+
+ if (structureMap.id) {
+ this.structureMapStore.set(structureMap.id, structureMap);
+ }
+ if (structureMap.url) {
+ this.structureMapStore.set(structureMap.url, structureMap);
+ }
+
+ this.logger.info('StructureMap registered', { id: structureMap.id });
+ }
+
+ /**
+ * Get all registered StructureMaps
+ */
+ getAllStructureMaps(): StructureMap[] {
+ const unique = new Map();
+ this.structureMapStore.forEach((structureMap) => {
+ const key = structureMap.id || structureMap.url || Math.random().toString();
+ unique.set(key, structureMap);
+ });
+ return Array.from(unique.values());
+ }
+
+ /**
+ * Search StructureMaps by parameters
+ */
+ searchStructureMaps(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ }): StructureMap[] {
+ let results = this.getAllStructureMaps();
+
+ if (params.name) {
+ results = results.filter(sm =>
+ sm.name?.toLowerCase().includes(params.name!.toLowerCase())
+ );
+ }
+
+ if (params.status) {
+ results = results.filter(sm => sm.status === params.status);
+ }
+
+ if (params.url) {
+ results = results.filter(sm => sm.url === params.url);
+ }
+
+ return results;
+ }
+
+ /**
+ * Remove StructureMap by ID or URL
+ */
+ removeStructureMap(reference: string): boolean {
+ this.logger.debug('Removing StructureMap', { reference });
+
+ const structureMap = this.structureMapStore.get(reference);
+ if (structureMap) {
+ if (structureMap.id) {
+ this.structureMapStore.delete(structureMap.id);
+ }
+ if (structureMap.url) {
+ this.structureMapStore.delete(structureMap.url);
+ }
+ this.logger.info('StructureMap removed', { reference });
+ return true;
+ }
+
+ this.logger.warn('StructureMap not found for removal', { reference });
+ return false;
+ }
+}
+
+// Export main classes and types
+export * from './types';
+export { FmlCompiler } from './lib/fml-compiler';
+export { StructureMapRetriever } from './lib/structure-map-retriever';
+export { StructureMapExecutor } from './lib/structure-map-executor';
+export { ValidationService } from './lib/validation-service';
+export { ConceptMapService } from './lib/conceptmap-service';
+export { ValueSetService } from './lib/valueset-service';
+export { CodeSystemService } from './lib/codesystem-service';
+export { BundleService, BundleProcessingResult } from './lib/bundle-service';
+export { Logger } from './lib/logger';
+export { SchemaValidator } from './lib/schema-validator';
\ No newline at end of file
diff --git a/packages/fmlrunner/src/lib/bundle-service.ts b/packages/fmlrunner/src/lib/bundle-service.ts
new file mode 100644
index 0000000..6624dca
--- /dev/null
+++ b/packages/fmlrunner/src/lib/bundle-service.ts
@@ -0,0 +1,313 @@
+import { Bundle, BundleEntry, StructureMap, StructureDefinition, ConceptMap, ValueSet, CodeSystem } from '../types';
+import { ConceptMapService } from './conceptmap-service';
+import { ValueSetService } from './valueset-service';
+import { CodeSystemService } from './codesystem-service';
+import { ValidationService } from './validation-service';
+import { Logger } from './logger';
+
+/**
+ * Result of processing a bundle
+ */
+export interface BundleProcessingResult {
+ success: boolean;
+ processed: {
+ structureMaps: number;
+ structureDefinitions: number;
+ conceptMaps: number;
+ valueSets: number;
+ codeSystems: number;
+ other: number;
+ };
+ errors: string[];
+ warnings: string[];
+}
+
+/**
+ * Service for processing FHIR Bundles and distributing resources to appropriate services
+ */
+export class BundleService {
+ private logger: Logger;
+
+ constructor(
+ private conceptMapService: ConceptMapService,
+ private valueSetService: ValueSetService,
+ private codeSystemService: CodeSystemService,
+ private validationService: ValidationService | undefined,
+ private structureMapStore: Map,
+ logger: Logger
+ ) {
+ this.logger = logger;
+ }
+
+ /**
+ * Process a FHIR Bundle and register all contained resources
+ */
+ processBundle(bundle: Bundle): BundleProcessingResult {
+ const result: BundleProcessingResult = {
+ success: true,
+ processed: {
+ structureMaps: 0,
+ structureDefinitions: 0,
+ conceptMaps: 0,
+ valueSets: 0,
+ codeSystems: 0,
+ other: 0
+ },
+ errors: [],
+ warnings: []
+ };
+
+ if (!bundle.entry || bundle.entry.length === 0) {
+ result.warnings.push('Bundle contains no entries');
+ return result;
+ }
+
+ for (let i = 0; i < bundle.entry.length; i++) {
+ const entry = bundle.entry[i];
+
+ try {
+ this.processEntry(entry, i, result);
+ } catch (error) {
+ const errorMsg = `Error processing entry ${i}: ${error instanceof Error ? error.message : 'Unknown error'}`;
+ result.errors.push(errorMsg);
+ result.success = false;
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Process a single bundle entry
+ */
+ private processEntry(entry: BundleEntry, index: number, result: BundleProcessingResult): void {
+ if (!entry.resource) {
+ result.warnings.push(`Entry ${index} has no resource`);
+ return;
+ }
+
+ const resource = entry.resource;
+
+ switch (resource.resourceType) {
+ case 'StructureMap':
+ this.processStructureMap(resource as StructureMap, index, result);
+ break;
+
+ case 'StructureDefinition':
+ this.processStructureDefinition(resource as StructureDefinition, index, result);
+ break;
+
+ case 'ConceptMap':
+ this.processConceptMap(resource as ConceptMap, index, result);
+ break;
+
+ case 'ValueSet':
+ this.processValueSet(resource as ValueSet, index, result);
+ break;
+
+ case 'CodeSystem':
+ this.processCodeSystem(resource as CodeSystem, index, result);
+ break;
+
+ default:
+ result.processed.other++;
+ result.warnings.push(`Entry ${index}: Unsupported resource type '${resource.resourceType}'`);
+ }
+ }
+
+ /**
+ * Process StructureMap resource
+ */
+ private processStructureMap(structureMap: StructureMap, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!structureMap.id && !structureMap.url) {
+ result.warnings.push(`Entry ${index}: StructureMap has no id or url, skipping`);
+ return;
+ }
+
+ // Store in StructureMap store if available
+ if (this.structureMapStore) {
+ if (structureMap.id) {
+ this.structureMapStore.set(structureMap.id, structureMap);
+ }
+ if (structureMap.url) {
+ this.structureMapStore.set(structureMap.url, structureMap);
+ }
+ }
+
+ result.processed.structureMaps++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process StructureMap - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Process StructureDefinition resource
+ */
+ private processStructureDefinition(structureDefinition: StructureDefinition, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!structureDefinition.id && !structureDefinition.url) {
+ result.warnings.push(`Entry ${index}: StructureDefinition has no id or url, skipping`);
+ return;
+ }
+
+ // Register with validation service if available
+ if (this.validationService) {
+ this.validationService.registerStructureDefinition(structureDefinition);
+ }
+
+ result.processed.structureDefinitions++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process StructureDefinition - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Process ConceptMap resource
+ */
+ private processConceptMap(conceptMap: ConceptMap, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!conceptMap.id && !conceptMap.url) {
+ result.warnings.push(`Entry ${index}: ConceptMap has no id or url, skipping`);
+ return;
+ }
+
+ this.conceptMapService.registerConceptMap(conceptMap);
+ result.processed.conceptMaps++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process ConceptMap - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Process ValueSet resource
+ */
+ private processValueSet(valueSet: ValueSet, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!valueSet.id && !valueSet.url) {
+ result.warnings.push(`Entry ${index}: ValueSet has no id or url, skipping`);
+ return;
+ }
+
+ this.valueSetService.registerValueSet(valueSet);
+ result.processed.valueSets++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process ValueSet - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Process CodeSystem resource
+ */
+ private processCodeSystem(codeSystem: CodeSystem, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!codeSystem.id && !codeSystem.url) {
+ result.warnings.push(`Entry ${index}: CodeSystem has no id or url, skipping`);
+ return;
+ }
+
+ this.codeSystemService.registerCodeSystem(codeSystem);
+ result.processed.codeSystems++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process CodeSystem - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Create a summary bundle of all loaded resources
+ */
+ createSummaryBundle(): Bundle {
+ const entries: BundleEntry[] = [];
+
+ // Add StructureMaps
+ if (this.structureMapStore) {
+ const uniqueStructureMaps = new Map();
+ this.structureMapStore.forEach((sm) => {
+ const key = sm.id || sm.url || Math.random().toString();
+ uniqueStructureMaps.set(key, sm);
+ });
+
+ uniqueStructureMaps.forEach((sm) => {
+ entries.push({
+ fullUrl: sm.url || `StructureMap/${sm.id}`,
+ resource: sm
+ });
+ });
+ }
+
+ // Add StructureDefinitions
+ if (this.validationService) {
+ const structureDefinitions = this.validationService.getStructureDefinitions();
+ structureDefinitions.forEach((sd) => {
+ entries.push({
+ fullUrl: sd.url || `StructureDefinition/${sd.id}`,
+ resource: sd
+ });
+ });
+ }
+
+ // Add ConceptMaps
+ this.conceptMapService.getAllConceptMaps().forEach((cm) => {
+ entries.push({
+ fullUrl: cm.url || `ConceptMap/${cm.id}`,
+ resource: cm
+ });
+ });
+
+ // Add ValueSets
+ this.valueSetService.getAllValueSets().forEach((vs) => {
+ entries.push({
+ fullUrl: vs.url || `ValueSet/${vs.id}`,
+ resource: vs
+ });
+ });
+
+ // Add CodeSystems
+ this.codeSystemService.getAllCodeSystems().forEach((cs) => {
+ entries.push({
+ fullUrl: cs.url || `CodeSystem/${cs.id}`,
+ resource: cs
+ });
+ });
+
+ return {
+ resourceType: 'Bundle',
+ id: 'loaded-resources-' + Date.now(),
+ type: 'collection',
+ timestamp: new Date().toISOString(),
+ total: entries.length,
+ entry: entries
+ };
+ }
+
+ /**
+ * Clear all loaded resources
+ */
+ clearAll(): void {
+ this.conceptMapService.clear();
+ this.valueSetService.clear();
+ this.codeSystemService.clear();
+ if (this.structureMapStore) {
+ this.structureMapStore.clear();
+ }
+ }
+
+ /**
+ * Get loading statistics
+ */
+ getStats(): {
+ structureMaps: number;
+ structureDefinitions: number;
+ conceptMaps: number;
+ valueSets: number;
+ codeSystems: number;
+ } {
+ return {
+ structureMaps: this.structureMapStore ? Array.from(new Set(Array.from(this.structureMapStore.values()).map(sm => sm.id || sm.url))).length : 0,
+ structureDefinitions: this.validationService ? this.validationService.getStructureDefinitions().length : 0,
+ conceptMaps: this.conceptMapService.getCount(),
+ valueSets: this.valueSetService.getCount(),
+ codeSystems: this.codeSystemService.getCount()
+ };
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/lib/codesystem-service.ts b/packages/fmlrunner/src/lib/codesystem-service.ts
new file mode 100644
index 0000000..db20c23
--- /dev/null
+++ b/packages/fmlrunner/src/lib/codesystem-service.ts
@@ -0,0 +1,271 @@
+import { CodeSystem } from '../types';
+import { Logger } from './logger';
+
+/**
+ * Service for managing CodeSystem resources
+ */
+export class CodeSystemService {
+ private codeSystems: Map = new Map();
+ private logger: Logger;
+
+ constructor(logger: Logger) {
+ this.logger = logger;
+ }
+
+ /**
+ * Register a CodeSystem resource
+ */
+ registerCodeSystem(codeSystem: CodeSystem): void {
+ if (codeSystem.id) {
+ this.codeSystems.set(codeSystem.id, codeSystem);
+ }
+ if (codeSystem.url) {
+ this.codeSystems.set(codeSystem.url, codeSystem);
+ }
+ }
+
+ /**
+ * Get CodeSystem by ID or URL
+ */
+ getCodeSystem(reference: string): CodeSystem | null {
+ return this.codeSystems.get(reference) || null;
+ }
+
+ /**
+ * Get all CodeSystems
+ */
+ getAllCodeSystems(): CodeSystem[] {
+ const unique = new Map();
+ this.codeSystems.forEach((codeSystem) => {
+ const key = codeSystem.id || codeSystem.url || Math.random().toString();
+ unique.set(key, codeSystem);
+ });
+ return Array.from(unique.values());
+ }
+
+ /**
+ * Search CodeSystems by parameters
+ */
+ searchCodeSystems(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ system?: string;
+ publisher?: string;
+ content?: string;
+ }): CodeSystem[] {
+ let results = this.getAllCodeSystems();
+
+ if (params.name) {
+ results = results.filter(cs =>
+ cs.name?.toLowerCase().includes(params.name!.toLowerCase()) ||
+ cs.title?.toLowerCase().includes(params.name!.toLowerCase())
+ );
+ }
+
+ if (params.status) {
+ results = results.filter(cs => cs.status === params.status);
+ }
+
+ if (params.url || params.system) {
+ const searchUrl = params.url || params.system;
+ results = results.filter(cs => cs.url === searchUrl);
+ }
+
+ if (params.publisher) {
+ results = results.filter(cs =>
+ cs.publisher?.toLowerCase().includes(params.publisher!.toLowerCase())
+ );
+ }
+
+ if (params.content) {
+ results = results.filter(cs => cs.content === params.content);
+ }
+
+ return results;
+ }
+
+ /**
+ * Remove CodeSystem by ID or URL
+ */
+ removeCodeSystem(reference: string): boolean {
+ const codeSystem = this.codeSystems.get(reference);
+ if (codeSystem) {
+ // Remove by both ID and URL if present
+ if (codeSystem.id) {
+ this.codeSystems.delete(codeSystem.id);
+ }
+ if (codeSystem.url) {
+ this.codeSystems.delete(codeSystem.url);
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Validate a code in a CodeSystem
+ */
+ validateCode(
+ systemRef: string,
+ code: string,
+ display?: string
+ ): { result: boolean; display?: string; message?: string } {
+ const codeSystem = this.getCodeSystem(systemRef);
+ if (!codeSystem) {
+ return { result: false, message: `CodeSystem not found: ${systemRef}` };
+ }
+
+ if (!codeSystem.concept) {
+ // If no concepts defined, assume code is valid if CodeSystem exists
+ return { result: true, message: 'CodeSystem contains no concept definitions' };
+ }
+
+ const found = this.findConcept(codeSystem.concept, code);
+ if (found) {
+ if (display && found.display && found.display !== display) {
+ return {
+ result: false,
+ message: `Display mismatch. Expected: ${found.display}, got: ${display}`
+ };
+ }
+ return { result: true, display: found.display };
+ }
+
+ return { result: false, message: `Code not found in CodeSystem: ${code}` };
+ }
+
+ /**
+ * Helper method to recursively search concepts
+ */
+ private findConcept(concepts: any[], code: string): any | null {
+ for (const concept of concepts) {
+ if (concept.code === code) {
+ return concept;
+ }
+ // Search nested concepts
+ if (concept.concept) {
+ const found = this.findConcept(concept.concept, code);
+ if (found) return found;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Get concept definition from CodeSystem
+ */
+ lookup(
+ systemRef: string,
+ code: string,
+ property?: string[]
+ ): {
+ name?: string;
+ display?: string;
+ definition?: string;
+ designation?: any[];
+ property?: any[];
+ } | null {
+ const codeSystem = this.getCodeSystem(systemRef);
+ if (!codeSystem?.concept) {
+ return null;
+ }
+
+ const concept = this.findConcept(codeSystem.concept, code);
+ if (!concept) {
+ return null;
+ }
+
+ const result: any = {
+ name: codeSystem.name,
+ display: concept.display,
+ definition: concept.definition
+ };
+
+ if (concept.designation) {
+ result.designation = concept.designation;
+ }
+
+ if (concept.property && property) {
+ result.property = concept.property.filter((p: any) =>
+ property.includes(p.code)
+ );
+ } else if (concept.property) {
+ result.property = concept.property;
+ }
+
+ return result;
+ }
+
+ /**
+ * Subsumption testing (basic implementation)
+ */
+ subsumes(
+ systemRef: string,
+ codeA: string,
+ codeB: string
+ ): 'equivalent' | 'subsumes' | 'subsumed-by' | 'not-subsumed' {
+ const codeSystem = this.getCodeSystem(systemRef);
+ if (!codeSystem?.concept) {
+ return 'not-subsumed';
+ }
+
+ if (codeA === codeB) {
+ return 'equivalent';
+ }
+
+ // Basic implementation - would need hierarchy traversal for full support
+ const conceptA = this.findConcept(codeSystem.concept, codeA);
+ const conceptB = this.findConcept(codeSystem.concept, codeB);
+
+ if (!conceptA || !conceptB) {
+ return 'not-subsumed';
+ }
+
+ // Check if B is a child of A
+ if (this.isChildOf(conceptA, codeB)) {
+ return 'subsumes';
+ }
+
+ // Check if A is a child of B
+ if (this.isChildOf(conceptB, codeA)) {
+ return 'subsumed-by';
+ }
+
+ return 'not-subsumed';
+ }
+
+ /**
+ * Helper to check if a concept has a child with the given code
+ */
+ private isChildOf(concept: any, code: string): boolean {
+ if (!concept.concept) {
+ return false;
+ }
+
+ for (const child of concept.concept) {
+ if (child.code === code) {
+ return true;
+ }
+ if (this.isChildOf(child, code)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Clear all CodeSystems
+ */
+ clear(): void {
+ this.codeSystems.clear();
+ }
+
+ /**
+ * Get count of registered CodeSystems
+ */
+ getCount(): number {
+ return this.getAllCodeSystems().length;
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/lib/conceptmap-service.ts b/packages/fmlrunner/src/lib/conceptmap-service.ts
new file mode 100644
index 0000000..d41f470
--- /dev/null
+++ b/packages/fmlrunner/src/lib/conceptmap-service.ts
@@ -0,0 +1,160 @@
+import { ConceptMap } from '../types';
+import { Logger } from './logger';
+
+/**
+ * Service for managing ConceptMap resources
+ */
+export class ConceptMapService {
+ private conceptMaps: Map = new Map();
+ private logger: Logger;
+
+ constructor(logger: Logger) {
+ this.logger = logger;
+ }
+
+ /**
+ * Register a ConceptMap resource
+ */
+ registerConceptMap(conceptMap: ConceptMap): void {
+ if (conceptMap.id) {
+ this.conceptMaps.set(conceptMap.id, conceptMap);
+ }
+ if (conceptMap.url) {
+ this.conceptMaps.set(conceptMap.url, conceptMap);
+ }
+ }
+
+ /**
+ * Get ConceptMap by ID or URL
+ */
+ getConceptMap(reference: string): ConceptMap | null {
+ return this.conceptMaps.get(reference) || null;
+ }
+
+ /**
+ * Get all ConceptMaps
+ */
+ getAllConceptMaps(): ConceptMap[] {
+ const unique = new Map();
+ this.conceptMaps.forEach((conceptMap) => {
+ const key = conceptMap.id || conceptMap.url || Math.random().toString();
+ unique.set(key, conceptMap);
+ });
+ return Array.from(unique.values());
+ }
+
+ /**
+ * Search ConceptMaps by parameters
+ */
+ searchConceptMaps(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ source?: string;
+ target?: string;
+ }): ConceptMap[] {
+ let results = this.getAllConceptMaps();
+
+ if (params.name) {
+ results = results.filter(cm =>
+ cm.name?.toLowerCase().includes(params.name!.toLowerCase())
+ );
+ }
+
+ if (params.status) {
+ results = results.filter(cm => cm.status === params.status);
+ }
+
+ if (params.url) {
+ results = results.filter(cm => cm.url === params.url);
+ }
+
+ if (params.source) {
+ results = results.filter(cm =>
+ cm.sourceUri === params.source || cm.sourceCanonical === params.source
+ );
+ }
+
+ if (params.target) {
+ results = results.filter(cm =>
+ cm.targetUri === params.target || cm.targetCanonical === params.target
+ );
+ }
+
+ return results;
+ }
+
+ /**
+ * Remove ConceptMap by ID or URL
+ */
+ removeConceptMap(reference: string): boolean {
+ const conceptMap = this.conceptMaps.get(reference);
+ if (conceptMap) {
+ // Remove by both ID and URL if present
+ if (conceptMap.id) {
+ this.conceptMaps.delete(conceptMap.id);
+ }
+ if (conceptMap.url) {
+ this.conceptMaps.delete(conceptMap.url);
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Translate a code using ConceptMaps
+ */
+ translate(
+ sourceSystem: string,
+ sourceCode: string,
+ targetSystem?: string
+ ): Array<{ system?: string; code?: string; display?: string; equivalence: string }> {
+ const results: Array<{ system?: string; code?: string; display?: string; equivalence: string }> = [];
+
+ // Find relevant ConceptMaps
+ const relevantMaps = this.getAllConceptMaps().filter(cm => {
+ const sourceMatch = cm.sourceUri === sourceSystem || cm.sourceCanonical === sourceSystem;
+ const targetMatch = !targetSystem || cm.targetUri === targetSystem || cm.targetCanonical === targetSystem;
+ return sourceMatch && targetMatch;
+ });
+
+ // Search for translations
+ for (const conceptMap of relevantMaps) {
+ if (conceptMap.group) {
+ for (const group of conceptMap.group) {
+ if (group.source === sourceSystem || !group.source) {
+ for (const element of group.element) {
+ if (element.code === sourceCode && element.target) {
+ for (const target of element.target) {
+ results.push({
+ system: group.target,
+ code: target.code,
+ display: target.display,
+ equivalence: target.equivalence
+ });
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return results;
+ }
+
+ /**
+ * Clear all ConceptMaps
+ */
+ clear(): void {
+ this.conceptMaps.clear();
+ }
+
+ /**
+ * Get count of registered ConceptMaps
+ */
+ getCount(): number {
+ return this.getAllConceptMaps().length;
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/lib/fml-compiler.ts b/packages/fmlrunner/src/lib/fml-compiler.ts
new file mode 100644
index 0000000..38d75dd
--- /dev/null
+++ b/packages/fmlrunner/src/lib/fml-compiler.ts
@@ -0,0 +1,741 @@
+import { StructureMap, FmlCompilationResult, StructureMapGroup, StructureMapGroupInput, StructureMapGroupRule, StructureMapGroupRuleSource, StructureMapGroupRuleTarget } from '../types';
+import { Logger } from './logger';
+
+/**
+ * FML Token types based on FHIR Mapping Language specification
+ */
+enum TokenType {
+ // Keywords
+ MAP = 'MAP',
+ USES = 'USES',
+ IMPORTS = 'IMPORTS',
+ CONCEPTMAP = 'CONCEPTMAP',
+ PREFIX = 'PREFIX',
+ GROUP = 'GROUP',
+ INPUT = 'INPUT',
+ RULE = 'RULE',
+ WHERE = 'WHERE',
+ CHECK = 'CHECK',
+ LOG = 'LOG',
+ AS = 'AS',
+ ALIAS = 'ALIAS',
+ MODE = 'MODE',
+
+ // Identifiers and literals
+ IDENTIFIER = 'IDENTIFIER',
+ STRING = 'STRING',
+ NUMBER = 'NUMBER',
+ CONSTANT = 'CONSTANT',
+
+ // Operators and symbols
+ ARROW = '->',
+ COLON = ':',
+ SEMICOLON = ';',
+ COMMA = ',',
+ DOT = '.',
+ EQUALS = '=',
+ LPAREN = '(',
+ RPAREN = ')',
+ LBRACE = '{',
+ RBRACE = '}',
+ LBRACKET = '[',
+ RBRACKET = ']',
+
+ // Special
+ NEWLINE = 'NEWLINE',
+ EOF = 'EOF',
+ WHITESPACE = 'WHITESPACE',
+ COMMENT = 'COMMENT'
+}
+
+/**
+ * FML Token
+ */
+interface Token {
+ type: TokenType;
+ value: string;
+ line: number;
+ column: number;
+}
+
+/**
+ * FML Tokenizer for FHIR Mapping Language
+ */
+class FmlTokenizer {
+ private input: string;
+ private position: number = 0;
+ private line: number = 1;
+ private column: number = 1;
+
+ constructor(input: string) {
+ this.input = input;
+ }
+
+ /**
+ * Tokenize the input string
+ */
+ tokenize(): Token[] {
+ const tokens: Token[] = [];
+
+ // Skip initial whitespace and newlines
+ while (!this.isAtEnd() && (this.isWhitespace(this.peek()) || this.peek() === '\n')) {
+ this.advance();
+ }
+
+ while (!this.isAtEnd()) {
+ const token = this.nextToken();
+ if (token && token.type !== TokenType.WHITESPACE && token.type !== TokenType.COMMENT && token.type !== TokenType.NEWLINE) {
+ tokens.push(token);
+ }
+ }
+
+ tokens.push({
+ type: TokenType.EOF,
+ value: '',
+ line: this.line,
+ column: this.column
+ });
+
+ return tokens;
+ }
+
+ private nextToken(): Token | null {
+ if (this.isAtEnd()) return null;
+
+ const start = this.position;
+ const startLine = this.line;
+ const startColumn = this.column;
+ const char = this.advance();
+
+ // Skip whitespace
+ if (this.isWhitespace(char)) {
+ while (!this.isAtEnd() && this.isWhitespace(this.peek())) {
+ this.advance();
+ }
+ return {
+ type: TokenType.WHITESPACE,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle newlines
+ if (char === '\n') {
+ return {
+ type: TokenType.NEWLINE,
+ value: char,
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle comments
+ if (char === '/') {
+ if (this.peek() === '/') {
+ // Single-line comment or documentation comment
+ if (this.position + 1 < this.input.length && this.input.charAt(this.position + 1) === '/') {
+ // Documentation comment: ///
+ this.advance(); // Skip second /
+ while (!this.isAtEnd() && this.peek() !== '\n') {
+ this.advance();
+ }
+ return {
+ type: TokenType.COMMENT,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ } else {
+ // Regular single-line comment: //
+ while (!this.isAtEnd() && this.peek() !== '\n') {
+ this.advance();
+ }
+ return {
+ type: TokenType.COMMENT,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ }
+ } else if (this.peek() === '*') {
+ // Multi-line comment: /* ... */
+ this.advance(); // Skip *
+ while (!this.isAtEnd()) {
+ if (this.peek() === '*' && this.position + 1 < this.input.length && this.input.charAt(this.position + 1) === '/') {
+ this.advance(); // Skip *
+ this.advance(); // Skip /
+ break;
+ }
+ this.advance();
+ }
+ return {
+ type: TokenType.COMMENT,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ }
+ }
+
+ // Handle strings
+ if (char === '"' || char === "'") {
+ const quote = char;
+ while (!this.isAtEnd() && this.peek() !== quote) {
+ if (this.peek() === '\\') this.advance(); // Skip escaped characters
+ this.advance();
+ }
+ if (!this.isAtEnd()) this.advance(); // Closing quote
+
+ return {
+ type: TokenType.STRING,
+ value: this.input.substring(start + 1, this.position - 1), // Remove quotes
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle numbers
+ if (this.isDigit(char)) {
+ while (!this.isAtEnd() && (this.isDigit(this.peek()) || this.peek() === '.')) {
+ this.advance();
+ }
+ return {
+ type: TokenType.NUMBER,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle identifiers and keywords
+ if (this.isAlpha(char) || char === '_') {
+ while (!this.isAtEnd() && (this.isAlphaNumeric(this.peek()) || this.peek() === '_')) {
+ this.advance();
+ }
+
+ const value = this.input.substring(start, this.position);
+ const type = this.getKeywordType(value.toUpperCase()) || TokenType.IDENTIFIER;
+
+ return {
+ type,
+ value,
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle operators and symbols
+ switch (char) {
+ case '-':
+ if (this.peek() === '>') {
+ this.advance();
+ return { type: TokenType.ARROW, value: '->', line: startLine, column: startColumn };
+ }
+ break;
+ case ':': return { type: TokenType.COLON, value: char, line: startLine, column: startColumn };
+ case ';': return { type: TokenType.SEMICOLON, value: char, line: startLine, column: startColumn };
+ case ',': return { type: TokenType.COMMA, value: char, line: startLine, column: startColumn };
+ case '.': return { type: TokenType.DOT, value: char, line: startLine, column: startColumn };
+ case '=': return { type: TokenType.EQUALS, value: char, line: startLine, column: startColumn };
+ case '(': return { type: TokenType.LPAREN, value: char, line: startLine, column: startColumn };
+ case ')': return { type: TokenType.RPAREN, value: char, line: startLine, column: startColumn };
+ case '{': return { type: TokenType.LBRACE, value: char, line: startLine, column: startColumn };
+ case '}': return { type: TokenType.RBRACE, value: char, line: startLine, column: startColumn };
+ case '[': return { type: TokenType.LBRACKET, value: char, line: startLine, column: startColumn };
+ case ']': return { type: TokenType.RBRACKET, value: char, line: startLine, column: startColumn };
+ }
+
+ throw new Error(`Unexpected character '${char}' at line ${startLine}, column ${startColumn}`);
+ }
+
+ private getKeywordType(keyword: string): TokenType | null {
+ const keywords: { [key: string]: TokenType } = {
+ 'MAP': TokenType.MAP,
+ 'USES': TokenType.USES,
+ 'IMPORTS': TokenType.IMPORTS,
+ 'CONCEPTMAP': TokenType.CONCEPTMAP,
+ 'PREFIX': TokenType.PREFIX,
+ 'GROUP': TokenType.GROUP,
+ 'INPUT': TokenType.INPUT,
+ 'RULE': TokenType.RULE,
+ 'WHERE': TokenType.WHERE,
+ 'CHECK': TokenType.CHECK,
+ 'LOG': TokenType.LOG,
+ 'AS': TokenType.AS,
+ 'ALIAS': TokenType.ALIAS,
+ 'MODE': TokenType.MODE
+ };
+
+ return keywords[keyword] || null;
+ }
+
+ private isAtEnd(): boolean {
+ return this.position >= this.input.length;
+ }
+
+ private advance(): string {
+ const char = this.input.charAt(this.position++);
+ if (char === '\n') {
+ this.line++;
+ this.column = 1;
+ } else {
+ this.column++;
+ }
+ return char;
+ }
+
+ private peek(): string {
+ if (this.isAtEnd()) return '\0';
+ return this.input.charAt(this.position);
+ }
+
+ private isWhitespace(char: string): boolean {
+ return char === ' ' || char === '\t' || char === '\r';
+ }
+
+ private isDigit(char: string): boolean {
+ return char >= '0' && char <= '9';
+ }
+
+ private isAlpha(char: string): boolean {
+ return (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z');
+ }
+
+ private isAlphaNumeric(char: string): boolean {
+ return this.isAlpha(char) || this.isDigit(char);
+ }
+}
+
+/**
+ * FML Parser for FHIR Mapping Language
+ */
+class FmlParser {
+ private tokens: Token[];
+ private current: number = 0;
+
+ constructor(tokens: Token[]) {
+ this.tokens = tokens;
+ }
+
+ /**
+ * Parse tokens into a StructureMap
+ */
+ parse(): StructureMap {
+ try {
+ return this.parseMap();
+ } catch (error) {
+ // If parsing fails, try partial parsing to extract what we can
+ return this.attemptPartialParse();
+ }
+ }
+
+ private attemptPartialParse(): StructureMap {
+ // Reset to beginning
+ this.current = 0;
+
+ // Try to extract basic map info even if full parsing fails
+ let url = 'http://example.org/StructureMap/DefaultMap';
+ let name = 'DefaultMap';
+
+ // Look for map declaration anywhere in the token stream
+ while (this.current < this.tokens.length - 1) {
+ if (this.tokens[this.current].type === TokenType.MAP) {
+ try {
+ this.current++; // Skip MAP token
+ if (this.current < this.tokens.length && this.tokens[this.current].type === TokenType.STRING) {
+ url = this.tokens[this.current].value;
+ this.current++;
+ if (this.current < this.tokens.length && this.tokens[this.current].type === TokenType.EQUALS) {
+ this.current++;
+ if (this.current < this.tokens.length && this.tokens[this.current].type === TokenType.STRING) {
+ name = this.tokens[this.current].value;
+ break;
+ }
+ }
+ }
+ } catch (error) {
+ // Continue looking
+ }
+ }
+ this.current++;
+ }
+
+ return this.createFallbackStructureMap(url, name);
+ }
+
+ private createFallbackStructureMap(url?: string, name?: string): StructureMap {
+ // Create a basic StructureMap for cases where parsing fails
+ return {
+ resourceType: 'StructureMap',
+ url: url || 'http://example.org/StructureMap/DefaultMap',
+ name: name || 'DefaultMap',
+ status: 'draft',
+ group: [{
+ name: 'main',
+ input: [
+ { name: 'source', mode: 'source' as 'source' },
+ { name: 'target', mode: 'target' as 'target' }
+ ],
+ rule: []
+ }]
+ };
+ }
+
+ private parseMap(): StructureMap {
+ let url = 'http://example.org/StructureMap/DefaultMap';
+ let name = 'DefaultMap';
+
+ // Check if there's a map declaration at the beginning
+ if (this.check(TokenType.MAP)) {
+ // Parse map declaration: map "url" = "name"
+ this.consume(TokenType.MAP, "Expected 'map' keyword");
+
+ url = this.consume(TokenType.STRING, "Expected URL string after 'map'").value;
+ this.consume(TokenType.EQUALS, "Expected '=' after map URL");
+ name = this.consume(TokenType.STRING, "Expected name string after '='").value;
+ }
+
+ const structureMap: StructureMap = {
+ resourceType: 'StructureMap',
+ url,
+ name,
+ status: 'draft',
+ group: []
+ };
+
+ // Parse optional uses statements
+ while (this.match(TokenType.USES)) {
+ this.parseUses();
+ }
+
+ // Parse optional imports statements
+ while (this.match(TokenType.IMPORTS)) {
+ this.parseImports();
+ }
+
+ // Parse optional prefix declarations
+ while (this.match(TokenType.PREFIX)) {
+ this.parsePrefix();
+ }
+
+ // Parse optional conceptmap declarations
+ while (this.match(TokenType.CONCEPTMAP)) {
+ this.parseConceptMap();
+ }
+
+ // Parse groups
+ while (this.match(TokenType.GROUP)) {
+ const group = this.parseGroup();
+ structureMap.group.push(group);
+ }
+
+ // If no groups were defined, create a default one and parse any remaining rules
+ if (structureMap.group.length === 0) {
+ const defaultGroup: StructureMapGroup = {
+ name: 'main',
+ input: [
+ { name: 'source', mode: 'source' as 'source' },
+ { name: 'target', mode: 'target' as 'target' }
+ ],
+ rule: []
+ };
+
+ // Parse any remaining rules at the top level
+ while (!this.isAtEnd()) {
+ if (this.check(TokenType.IDENTIFIER)) {
+ // Try to parse as a rule
+ try {
+ const rule = this.parseRule();
+ if (rule) {
+ defaultGroup.rule.push(rule as StructureMapGroupRule);
+ }
+ } catch (error) {
+ // Skip malformed rules
+ this.advance();
+ }
+ } else {
+ this.advance(); // Skip unexpected tokens
+ }
+ }
+
+ structureMap.group.push(defaultGroup);
+ }
+
+ return structureMap;
+ }
+
+ private parseUses(): void {
+ // uses "url" alias name as mode
+ const url = this.consume(TokenType.STRING, "Expected URL after 'uses'").value;
+
+ // Check if there's an alias keyword
+ if (this.match(TokenType.ALIAS)) {
+ const alias = this.consume(TokenType.IDENTIFIER, "Expected alias name after 'alias'").value;
+ this.consume(TokenType.AS, "Expected 'as' after alias name");
+ const mode = this.consume(TokenType.IDENTIFIER, "Expected mode after 'as'").value;
+ // TODO: Store uses information in StructureMap
+ }
+ }
+
+ private parseImports(): void {
+ // imports "url"
+ const url = this.consume(TokenType.STRING, "Expected URL after 'imports'").value;
+ // TODO: Store imports information in StructureMap
+ }
+
+ private parsePrefix(): void {
+ // prefix system = "url"
+ const prefix = this.consume(TokenType.IDENTIFIER, "Expected prefix name after 'prefix'").value;
+ this.consume(TokenType.EQUALS, "Expected '=' after prefix name");
+ const url = this.consume(TokenType.STRING, "Expected URL after '='").value;
+ // TODO: Store prefix information in StructureMap
+ }
+
+ private parseConceptMap(): void {
+ // conceptmap "url" { ... }
+ const url = this.consume(TokenType.STRING, "Expected URL after 'conceptmap'").value;
+ this.consume(TokenType.LBRACE, "Expected '{' after conceptmap URL");
+
+ // Skip content inside braces for now - conceptmap parsing is complex
+ let braceCount = 1;
+ while (!this.isAtEnd() && braceCount > 0) {
+ if (this.check(TokenType.LBRACE)) {
+ braceCount++;
+ } else if (this.check(TokenType.RBRACE)) {
+ braceCount--;
+ }
+ this.advance();
+ }
+ // TODO: Store conceptmap information in StructureMap
+ }
+
+ private parseGroup(): StructureMapGroup {
+ const name = this.consume(TokenType.IDENTIFIER, "Expected group name").value;
+ this.consume(TokenType.LPAREN, "Expected '(' after group name");
+
+ const inputs: StructureMapGroupInput[] = [];
+
+ // Parse input parameters
+ if (!this.check(TokenType.RPAREN)) {
+ do {
+ const input = this.parseInput();
+ inputs.push(input);
+ } while (this.match(TokenType.COMMA));
+ }
+
+ this.consume(TokenType.RPAREN, "Expected ')' after group inputs");
+
+ const rules: StructureMapGroupRule[] = [];
+
+ // Parse rules
+ while (!this.isAtEnd() && !this.check(TokenType.GROUP)) {
+ if (this.match(TokenType.IDENTIFIER)) {
+ // This is likely a rule - backup and parse it
+ this.current--;
+ const rule = this.parseRule();
+ if (rule) {
+ rules.push(rule);
+ }
+ } else {
+ this.advance(); // Skip unexpected tokens
+ }
+ }
+
+ return {
+ name,
+ input: inputs,
+ rule: rules
+ };
+ }
+
+ private parseInput(): StructureMapGroupInput {
+ // Parse: mode name : type
+ const firstToken = this.consume(TokenType.IDENTIFIER, "Expected mode or name").value;
+
+ // Check if this is mode name : type pattern
+ if (this.check(TokenType.IDENTIFIER)) {
+ // First token is mode, second is name
+ const mode = firstToken as 'source' | 'target';
+ const name = this.consume(TokenType.IDENTIFIER, "Expected input name").value;
+ this.consume(TokenType.COLON, "Expected ':' after input name");
+ const type = this.consume(TokenType.IDENTIFIER, "Expected input type").value;
+
+ return {
+ name,
+ type,
+ mode: (mode === 'source' || mode === 'target') ? mode : 'source'
+ };
+ } else {
+ // Original pattern: name : type [as mode]
+ const name = firstToken;
+ this.consume(TokenType.COLON, "Expected ':' after input name");
+ const type = this.consume(TokenType.IDENTIFIER, "Expected input type").value;
+
+ let mode: 'source' | 'target' = 'source'; // default
+ if (this.match(TokenType.AS)) {
+ const modeValue = this.consume(TokenType.IDENTIFIER, "Expected mode after 'as'").value;
+ if (modeValue === 'source' || modeValue === 'target') {
+ mode = modeValue;
+ }
+ }
+
+ return {
+ name,
+ type,
+ mode
+ };
+ }
+ }
+
+ private parseRule(): StructureMapGroupRule {
+ const name = this.consume(TokenType.IDENTIFIER, "Expected rule name").value;
+ this.consume(TokenType.COLON, "Expected ':' after rule name");
+
+ const sources: StructureMapGroupRuleSource[] = [];
+ const targets: StructureMapGroupRuleTarget[] = [];
+
+ // Parse source expressions
+ do {
+ const source = this.parseExpression();
+ sources.push(source as StructureMapGroupRuleSource);
+ } while (this.match(TokenType.COMMA));
+
+ this.consume(TokenType.ARROW, "Expected '->' in rule");
+
+ // Parse target expressions
+ do {
+ const target = this.parseExpression();
+ targets.push(target as StructureMapGroupRuleTarget);
+ } while (this.match(TokenType.COMMA));
+
+ // Optional semicolon
+ this.match(TokenType.SEMICOLON);
+
+ return {
+ name,
+ source: sources,
+ target: targets
+ };
+ }
+
+ private parseExpression(): any {
+ let context = 'source';
+ let element = '';
+
+ if (this.check(TokenType.IDENTIFIER)) {
+ const token = this.advance();
+ context = token.value;
+
+ if (this.match(TokenType.DOT)) {
+ element = this.consume(TokenType.IDENTIFIER, "Expected element name after '.'").value;
+ }
+ }
+
+ return {
+ context,
+ element
+ };
+ }
+
+ // Utility methods
+ private match(...types: TokenType[]): boolean {
+ for (const type of types) {
+ if (this.check(type)) {
+ this.advance();
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private check(type: TokenType): boolean {
+ if (this.isAtEnd()) return false;
+ return this.peek().type === type;
+ }
+
+ private advance(): Token {
+ if (!this.isAtEnd()) this.current++;
+ return this.previous();
+ }
+
+ private isAtEnd(): boolean {
+ return this.current >= this.tokens.length || this.peek().type === TokenType.EOF;
+ }
+
+ private peek(): Token {
+ if (this.current >= this.tokens.length) {
+ return { type: TokenType.EOF, value: '', line: 0, column: 0 };
+ }
+ return this.tokens[this.current];
+ }
+
+ private previous(): Token {
+ return this.tokens[this.current - 1];
+ }
+
+ private consume(type: TokenType, message: string): Token {
+ if (this.check(type)) return this.advance();
+
+ const current = this.peek();
+ throw new Error(`${message}. Got ${current.type} '${current.value}' at line ${current.line}, column ${current.column}`);
+ }
+}
+
+/**
+ * Enhanced FML Compiler with proper tokenization and grammar handling
+ */
+export class FmlCompiler {
+ private logger: Logger;
+
+ constructor(logger: Logger) {
+ this.logger = logger;
+ }
+
+ /**
+ * Compile FML content to a StructureMap using proper parsing
+ * @param fmlContent The FML content to compile
+ * @returns Compilation result with StructureMap or errors
+ */
+ compile(fmlContent: string): FmlCompilationResult {
+ try {
+ // Basic validation
+ if (!fmlContent || fmlContent.trim().length === 0) {
+ return {
+ success: false,
+ errors: ['FML content cannot be empty']
+ };
+ }
+
+ // Tokenize the FML content
+ const tokenizer = new FmlTokenizer(fmlContent);
+ const tokens = tokenizer.tokenize();
+
+ // Parse tokens into StructureMap
+ const parser = new FmlParser(tokens);
+ const structureMap = parser.parse();
+
+ return {
+ success: true,
+ structureMap
+ };
+ } catch (error) {
+ return {
+ success: false,
+ errors: [error instanceof Error ? error.message : 'Unknown compilation error']
+ };
+ }
+ }
+
+ /**
+ * Legacy method for backwards compatibility - now uses the new parser
+ * @deprecated Use compile() method instead
+ */
+ parseFmlToStructureMap(fmlContent: string): StructureMap {
+ const result = this.compile(fmlContent);
+ if (result.success && result.structureMap) {
+ return result.structureMap;
+ }
+ throw new Error(result.errors?.join(', ') || 'Compilation failed');
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/lib/logger.ts b/packages/fmlrunner/src/lib/logger.ts
new file mode 100644
index 0000000..bd93504
--- /dev/null
+++ b/packages/fmlrunner/src/lib/logger.ts
@@ -0,0 +1,61 @@
+import winston from 'winston';
+
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'verbose' | 'silly';
+
+/**
+ * Logger class providing structured logging throughout the FML Runner
+ */
+export class Logger {
+ private logger: winston.Logger;
+
+ constructor(component: string, level: LogLevel = 'info') {
+ this.logger = winston.createLogger({
+ level,
+ format: winston.format.combine(
+ winston.format.timestamp(),
+ winston.format.errors({ stack: true }),
+ winston.format.json(),
+ winston.format.label({ label: component })
+ ),
+ defaultMeta: { component },
+ transports: [
+ new winston.transports.Console({
+ format: winston.format.combine(
+ winston.format.colorize(),
+ winston.format.simple()
+ )
+ })
+ ]
+ });
+ }
+
+ error(message: string, meta?: any): void {
+ this.logger.error(message, meta);
+ }
+
+ warn(message: string, meta?: any): void {
+ this.logger.warn(message, meta);
+ }
+
+ info(message: string, meta?: any): void {
+ this.logger.info(message, meta);
+ }
+
+ debug(message: string, meta?: any): void {
+ this.logger.debug(message, meta);
+ }
+
+ verbose(message: string, meta?: any): void {
+ this.logger.verbose(message, meta);
+ }
+
+ silly(message: string, meta?: any): void {
+ this.logger.silly(message, meta);
+ }
+
+ child(meta: any): Logger {
+ const childLogger = new Logger('child', this.logger.level as LogLevel);
+ childLogger.logger = this.logger.child(meta);
+ return childLogger;
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/lib/schema-validator.ts b/packages/fmlrunner/src/lib/schema-validator.ts
new file mode 100644
index 0000000..769f5c1
--- /dev/null
+++ b/packages/fmlrunner/src/lib/schema-validator.ts
@@ -0,0 +1,253 @@
+import Ajv, { JSONSchemaType } from 'ajv';
+import addFormats from 'ajv-formats';
+import { Logger } from './logger';
+import { StructureMap, StructureDefinition, ConceptMap, ValueSet, CodeSystem, Bundle } from '../types';
+
+export interface ValidationResult {
+ valid: boolean;
+ errors: string[];
+}
+
+/**
+ * Schema validator for JSON schema validation of input/output parameters
+ */
+export class SchemaValidator {
+ private ajv: Ajv;
+ private logger: Logger;
+
+ constructor(logger: Logger) {
+ this.logger = logger;
+ this.ajv = new Ajv({ allErrors: true, verbose: true });
+ addFormats(this.ajv);
+
+ // Load schemas
+ this.loadSchemas();
+ }
+
+ private loadSchemas(): void {
+ // FML Input Schema
+ const fmlInputSchema: JSONSchemaType = {
+ type: 'string',
+ minLength: 1,
+ pattern: '^map\\s+'
+ };
+ this.ajv.addSchema(fmlInputSchema, 'fml-input');
+
+ // StructureMap Schema (simplified)
+ const structureMapSchema = {
+ type: 'object',
+ properties: {
+ resourceType: { type: 'string', const: 'StructureMap' },
+ id: { type: 'string' },
+ url: { type: 'string', format: 'uri' },
+ name: { type: 'string' },
+ status: { type: 'string', enum: ['draft', 'active', 'retired', 'unknown'] }
+ },
+ required: ['resourceType'],
+ additionalProperties: true
+ };
+ this.ajv.addSchema(structureMapSchema, 'structure-map');
+
+ // Bundle Schema
+ const bundleSchema = {
+ type: 'object',
+ properties: {
+ resourceType: { type: 'string', const: 'Bundle' },
+ id: { type: 'string' },
+ type: { type: 'string' },
+ entry: {
+ type: 'array',
+ items: {
+ type: 'object',
+ properties: {
+ resource: { type: 'object' }
+ }
+ }
+ }
+ },
+ required: ['resourceType'],
+ additionalProperties: true
+ };
+ this.ajv.addSchema(bundleSchema, 'bundle');
+
+ // Execution Input Schema
+ const executionInputSchema = {
+ oneOf: [
+ { type: 'object' },
+ { type: 'array' },
+ { type: 'string' },
+ { type: 'number' },
+ { type: 'boolean' }
+ ]
+ };
+ this.ajv.addSchema(executionInputSchema, 'execution-input');
+
+ // StructureDefinition Schema
+ const structureDefinitionSchema = {
+ type: 'object',
+ properties: {
+ resourceType: { type: 'string', const: 'StructureDefinition' },
+ id: { type: 'string' },
+ url: { type: 'string', format: 'uri' },
+ name: { type: 'string' },
+ status: { type: 'string', enum: ['draft', 'active', 'retired', 'unknown'] }
+ },
+ required: ['resourceType'],
+ additionalProperties: true
+ };
+ this.ajv.addSchema(structureDefinitionSchema, 'structure-definition');
+ }
+
+ /**
+ * Validate FML input content
+ */
+ validateFmlInput(fmlContent: string): ValidationResult {
+ const validate = this.ajv.getSchema('fml-input');
+ if (!validate) {
+ return { valid: false, errors: ['FML input schema not found'] };
+ }
+
+ const valid = validate(fmlContent);
+ if (valid) {
+ return { valid: true, errors: [] };
+ }
+
+ const errors = validate.errors?.map(err =>
+ `${err.instancePath}: ${err.message}`
+ ) || ['Unknown validation error'];
+
+ this.logger.debug('FML input validation failed', { errors });
+ return { valid: false, errors };
+ }
+
+ /**
+ * Validate StructureMap output
+ */
+ validateStructureMapOutput(structureMap: StructureMap): ValidationResult {
+ const validate = this.ajv.getSchema('structure-map');
+ if (!validate) {
+ return { valid: false, errors: ['StructureMap schema not found'] };
+ }
+
+ const valid = validate(structureMap);
+ if (valid) {
+ return { valid: true, errors: [] };
+ }
+
+ const errors = validate.errors?.map(err =>
+ `${err.instancePath}: ${err.message}`
+ ) || ['Unknown validation error'];
+
+ this.logger.debug('StructureMap validation failed', { errors });
+ return { valid: false, errors };
+ }
+
+ /**
+ * Validate execution input
+ */
+ validateExecutionInput(input: any): ValidationResult {
+ const validate = this.ajv.getSchema('execution-input');
+ if (!validate) {
+ return { valid: false, errors: ['Execution input schema not found'] };
+ }
+
+ const valid = validate(input);
+ if (valid) {
+ return { valid: true, errors: [] };
+ }
+
+ const errors = validate.errors?.map(err =>
+ `${err.instancePath}: ${err.message}`
+ ) || ['Unknown validation error'];
+
+ this.logger.debug('Execution input validation failed', { errors });
+ return { valid: false, errors };
+ }
+
+ /**
+ * Validate execution output
+ */
+ validateExecutionOutput(output: any): ValidationResult {
+ // For now, accept any output format
+ // Could be enhanced with specific FHIR resource schemas
+ if (output === null || output === undefined) {
+ return { valid: false, errors: ['Output cannot be null or undefined'] };
+ }
+
+ return { valid: true, errors: [] };
+ }
+
+ /**
+ * Validate Bundle resource
+ */
+ validateBundle(bundle: Bundle): ValidationResult {
+ const validate = this.ajv.getSchema('bundle');
+ if (!validate) {
+ return { valid: false, errors: ['Bundle schema not found'] };
+ }
+
+ const valid = validate(bundle);
+ if (valid) {
+ return { valid: true, errors: [] };
+ }
+
+ const errors = validate.errors?.map(err =>
+ `${err.instancePath}: ${err.message}`
+ ) || ['Unknown validation error'];
+
+ this.logger.debug('Bundle validation failed', { errors });
+ return { valid: false, errors };
+ }
+
+ /**
+ * Validate StructureDefinition resource
+ */
+ validateStructureDefinition(structureDefinition: StructureDefinition): ValidationResult {
+ const validate = this.ajv.getSchema('structure-definition');
+ if (!validate) {
+ return { valid: false, errors: ['StructureDefinition schema not found'] };
+ }
+
+ const valid = validate(structureDefinition);
+ if (valid) {
+ return { valid: true, errors: [] };
+ }
+
+ const errors = validate.errors?.map(err =>
+ `${err.instancePath}: ${err.message}`
+ ) || ['Unknown validation error'];
+
+ this.logger.debug('StructureDefinition validation failed', { errors });
+ return { valid: false, errors };
+ }
+
+ /**
+ * Add custom schema
+ */
+ addSchema(schema: any, key: string): void {
+ this.ajv.addSchema(schema, key);
+ this.logger.debug('Custom schema added', { key });
+ }
+
+ /**
+ * Validate against custom schema
+ */
+ validateCustom(data: any, schemaKey: string): ValidationResult {
+ const validate = this.ajv.getSchema(schemaKey);
+ if (!validate) {
+ return { valid: false, errors: [`Schema '${schemaKey}' not found`] };
+ }
+
+ const valid = validate(data);
+ if (valid) {
+ return { valid: true, errors: [] };
+ }
+
+ const errors = validate.errors?.map(err =>
+ `${err.instancePath}: ${err.message}`
+ ) || ['Unknown validation error'];
+
+ this.logger.debug('Custom validation failed', { schemaKey, errors });
+ return { valid: false, errors };
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/lib/structure-map-executor.ts b/packages/fmlrunner/src/lib/structure-map-executor.ts
new file mode 100644
index 0000000..8b88ebd
--- /dev/null
+++ b/packages/fmlrunner/src/lib/structure-map-executor.ts
@@ -0,0 +1,425 @@
+import { StructureMap, ExecutionResult, ExecutionOptions, EnhancedExecutionResult } from '../types';
+import { ValidationService } from './validation-service';
+import { ConceptMapService } from './conceptmap-service';
+import { ValueSetService } from './valueset-service';
+import { CodeSystemService } from './codesystem-service';
+import { Logger } from './logger';
+import * as fhirpath from 'fhirpath';
+
+/**
+ * StructureMap execution engine - executes StructureMaps on input data
+ */
+export class StructureMapExecutor {
+ private validationService: ValidationService;
+ private conceptMapService?: ConceptMapService;
+ private valueSetService?: ValueSetService;
+ private codeSystemService?: CodeSystemService;
+ private logger: Logger;
+
+ constructor(logger: Logger) {
+ this.logger = logger;
+ this.validationService = new ValidationService(logger);
+ }
+
+ /**
+ * Set terminology services for advanced transformation support
+ */
+ setTerminologyServices(
+ conceptMapService: ConceptMapService,
+ valueSetService: ValueSetService,
+ codeSystemService: CodeSystemService
+ ): void {
+ this.conceptMapService = conceptMapService;
+ this.valueSetService = valueSetService;
+ this.codeSystemService = codeSystemService;
+ }
+
+ /**
+ * Execute a StructureMap on input content with optional validation
+ */
+ execute(structureMap: StructureMap, inputContent: any, options?: ExecutionOptions): EnhancedExecutionResult {
+ try {
+ // Basic validation
+ if (!structureMap) {
+ return {
+ success: false,
+ errors: ['StructureMap is required']
+ };
+ }
+
+ if (!structureMap.group || structureMap.group.length === 0) {
+ return {
+ success: false,
+ errors: ['StructureMap must have at least one group']
+ };
+ }
+
+ const result: EnhancedExecutionResult = {
+ success: true,
+ result: undefined,
+ validation: {}
+ };
+
+ // Validate input if requested
+ if (options?.validateInput && options?.inputProfile) {
+ const inputValidation = this.validationService.validate(inputContent, options.inputProfile);
+ result.validation!.input = inputValidation;
+
+ if (!inputValidation.valid && options?.strictMode) {
+ return {
+ success: false,
+ errors: [`Input validation failed: ${inputValidation.errors.map(e => e.message).join(', ')}`],
+ validation: result.validation
+ };
+ }
+ }
+
+ // Execute the main group
+ const mainGroup = structureMap.group.find(g => g.name === 'main') || structureMap.group[0];
+ const transformResult = this.executeGroup(mainGroup, inputContent);
+ result.result = transformResult;
+
+ // Validate output if requested
+ if (options?.validateOutput && options?.outputProfile) {
+ const outputValidation = this.validationService.validate(transformResult, options.outputProfile);
+ result.validation!.output = outputValidation;
+
+ if (!outputValidation.valid && options?.strictMode) {
+ return {
+ success: false,
+ errors: [`Output validation failed: ${outputValidation.errors.map(e => e.message).join(', ')}`],
+ validation: result.validation
+ };
+ }
+ }
+
+ return result;
+ } catch (error) {
+ return {
+ success: false,
+ errors: [error instanceof Error ? error.message : 'Unknown execution error']
+ };
+ }
+ }
+
+ /**
+ * Get the validation service for registering StructureDefinitions
+ */
+ getValidationService(): ValidationService {
+ return this.validationService;
+ }
+
+ /**
+ * Execute a group within a StructureMap
+ */
+ private executeGroup(group: any, inputContent: any): any {
+ // This is a basic implementation - a real StructureMap executor would be much more complex
+ // and would need to handle FHIR Path expressions, complex transformations, etc.
+
+ const result: any = {};
+
+ // Process each rule in the group
+ if (group.rule) {
+ for (const rule of group.rule) {
+ this.executeRule(rule, inputContent, result);
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Execute a single mapping rule
+ */
+ private executeRule(rule: any, source: any, target: any): void {
+ try {
+ // Basic rule execution - map simple element to element
+ if (rule.source && rule.target && rule.source.length > 0 && rule.target.length > 0) {
+ const sourceElement = rule.source[0].element;
+ const targetElement = rule.target[0].element;
+
+ if (sourceElement && targetElement && source[sourceElement] !== undefined) {
+ let value = source[sourceElement];
+
+ // Check if target has transform operations
+ const targetRule = rule.target[0];
+ if (targetRule.transform) {
+ value = this.applyTransform(targetRule.transform, value, targetRule.parameter);
+ }
+
+ target[targetElement] = value;
+ }
+ }
+ } catch (error) {
+ console.error('Error executing rule:', error);
+ }
+ }
+
+ /**
+ * Apply transform operations including terminology operations
+ */
+ private applyTransform(transform: string, value: any, parameters?: any[]): any {
+ switch (transform) {
+ case 'copy':
+ return value;
+
+ case 'translate':
+ return this.applyTranslateTransform(value, parameters);
+
+ case 'evaluate':
+ // FHIRPath evaluation - basic implementation
+ return this.evaluateFhirPath(value, parameters);
+
+ case 'create':
+ // Create a new resource/element
+ return this.createResource(parameters);
+
+ case 'reference':
+ // Create a reference
+ return this.createReference(value, parameters);
+
+ case 'dateOp':
+ // Date operations
+ return this.applyDateOperation(value, parameters);
+
+ case 'append':
+ // String append operation
+ return this.appendStrings(value, parameters);
+
+ case 'cast':
+ // Type casting
+ return this.castValue(value, parameters);
+
+ default:
+ console.warn(`Unknown transform: ${transform}`);
+ return value;
+ }
+ }
+
+ /**
+ * Apply translate transform using ConceptMaps
+ */
+ private applyTranslateTransform(value: any, parameters?: any[]): any {
+ if (!this.conceptMapService || !parameters || parameters.length < 2) {
+ return value;
+ }
+
+ try {
+ const sourceSystem = parameters[0];
+ const targetSystem = parameters[1];
+
+ if (typeof value === 'object' && value.code && value.system) {
+ // Handle Coding input
+ const translations = this.conceptMapService.translate(
+ value.system,
+ value.code,
+ targetSystem
+ );
+
+ if (translations.length > 0) {
+ const translation = translations[0];
+ return {
+ system: translation.system || targetSystem,
+ code: translation.code,
+ display: translation.display
+ };
+ }
+ } else if (typeof value === 'string') {
+ // Handle string code input
+ const translations = this.conceptMapService.translate(
+ sourceSystem,
+ value,
+ targetSystem
+ );
+
+ if (translations.length > 0) {
+ return translations[0].code;
+ }
+ }
+ } catch (error) {
+ console.error('Error in translate transform:', error);
+ }
+
+ return value;
+ }
+
+ /**
+ * FHIRPath evaluation using official HL7 FHIRPath library
+ */
+ private evaluateFhirPath(value: any, parameters?: any[]): any {
+ if (!parameters || parameters.length === 0) {
+ return value;
+ }
+
+ const expression = parameters[0];
+
+ try {
+ // Use the official HL7 FHIRPath library for proper evaluation
+ const result = fhirpath.evaluate(value, expression);
+
+ // FHIRPath returns an array of results, return first result or empty array
+ if (Array.isArray(result)) {
+ return result.length === 1 ? result[0] : result;
+ }
+
+ return result;
+ } catch (error) {
+ console.error(`FHIRPath evaluation failed for expression "${expression}":`, error);
+ // Return undefined for failed evaluations rather than partial results
+ return undefined;
+ }
+ }
+
+ /**
+ * Create a new resource or element
+ */
+ private createResource(parameters?: any[]): any {
+ if (!parameters || parameters.length === 0) {
+ return {};
+ }
+
+ const resourceType = parameters[0];
+ return { resourceType };
+ }
+
+ /**
+ * Create a reference
+ */
+ private createReference(value: any, parameters?: any[]): any {
+ if (typeof value === 'string') {
+ return { reference: value };
+ }
+
+ if (value && value.resourceType && value.id) {
+ return { reference: `${value.resourceType}/${value.id}` };
+ }
+
+ return value;
+ }
+
+ /**
+ * Apply date operations
+ */
+ private applyDateOperation(value: any, parameters?: any[]): any {
+ if (!parameters || parameters.length < 2) {
+ return value;
+ }
+
+ const operation = parameters[0];
+ const amount = parameters[1];
+
+ try {
+ const date = new Date(value);
+
+ switch (operation) {
+ case 'add':
+ return new Date(date.getTime() + amount * 24 * 60 * 60 * 1000).toISOString();
+ case 'subtract':
+ return new Date(date.getTime() - amount * 24 * 60 * 60 * 1000).toISOString();
+ case 'now':
+ return new Date().toISOString();
+ default:
+ return value;
+ }
+ } catch (error) {
+ return value;
+ }
+ }
+
+ /**
+ * Append strings
+ */
+ private appendStrings(value: any, parameters?: any[]): any {
+ if (!parameters || parameters.length === 0) {
+ return value;
+ }
+
+ let result = String(value || '');
+ for (const param of parameters) {
+ result += String(param);
+ }
+
+ return result;
+ }
+
+ /**
+ * Cast value to different type
+ */
+ private castValue(value: any, parameters?: any[]): any {
+ if (!parameters || parameters.length === 0) {
+ return value;
+ }
+
+ const targetType = parameters[0];
+
+ try {
+ switch (targetType) {
+ case 'string':
+ return String(value);
+ case 'integer':
+ return parseInt(value, 10);
+ case 'decimal':
+ return parseFloat(value);
+ case 'boolean':
+ return Boolean(value);
+ case 'date':
+ return new Date(value).toISOString().split('T')[0];
+ case 'dateTime':
+ return new Date(value).toISOString();
+ default:
+ return value;
+ }
+ } catch (error) {
+ return value;
+ }
+ }
+
+ /**
+ * Get terminology services for external access
+ */
+ getTerminologyServices(): {
+ conceptMapService?: ConceptMapService;
+ valueSetService?: ValueSetService;
+ codeSystemService?: CodeSystemService;
+ } {
+ return {
+ conceptMapService: this.conceptMapService,
+ valueSetService: this.valueSetService,
+ codeSystemService: this.codeSystemService
+ };
+ }
+
+ /**
+ * Validate that a StructureMap can be executed
+ */
+ validateStructureMap(structureMap: StructureMap): { valid: boolean; errors: string[] } {
+ const errors: string[] = [];
+
+ if (!structureMap) {
+ errors.push('StructureMap is null or undefined');
+ return { valid: false, errors };
+ }
+
+ if (structureMap.resourceType !== 'StructureMap') {
+ errors.push('Resource type must be "StructureMap"');
+ }
+
+ if (!structureMap.group || structureMap.group.length === 0) {
+ errors.push('StructureMap must have at least one group');
+ }
+
+ if (structureMap.group) {
+ for (let i = 0; i < structureMap.group.length; i++) {
+ const group = structureMap.group[i];
+ if (!group.name) {
+ errors.push(`Group ${i} must have a name`);
+ }
+ if (!group.input || group.input.length === 0) {
+ errors.push(`Group ${i} must have at least one input`);
+ }
+ }
+ }
+
+ return { valid: errors.length === 0, errors };
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/lib/structure-map-retriever.ts b/packages/fmlrunner/src/lib/structure-map-retriever.ts
new file mode 100644
index 0000000..7a1a35c
--- /dev/null
+++ b/packages/fmlrunner/src/lib/structure-map-retriever.ts
@@ -0,0 +1,112 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { StructureMap } from '../types';
+import { Logger } from './logger';
+
+/**
+ * StructureMap retrieval service - loads StructureMaps from files or URLs
+ */
+export class StructureMapRetriever {
+ private baseDirectory: string;
+ private cache: Map = new Map();
+ private logger: Logger;
+
+ constructor(logger: Logger, baseDirectory: string = './maps') {
+ this.logger = logger;
+ this.baseDirectory = baseDirectory;
+ }
+
+ /**
+ * Retrieve StructureMap by reference (file path or URL)
+ */
+ async getStructureMap(reference: string): Promise {
+ try {
+ // Check cache first
+ if (this.cache.has(reference)) {
+ return this.cache.get(reference) || null;
+ }
+
+ let structureMap: StructureMap | null = null;
+
+ if (reference.startsWith('http')) {
+ // Load from URL
+ structureMap = await this.loadFromUrl(reference);
+ } else {
+ // Load from file
+ structureMap = await this.loadFromFile(reference);
+ }
+
+ // Cache the result
+ if (structureMap) {
+ this.cache.set(reference, structureMap);
+ }
+
+ return structureMap;
+ } catch (error) {
+ console.error(`Error retrieving StructureMap ${reference}:`, error);
+ return null;
+ }
+ }
+
+ /**
+ * Load StructureMap from local file
+ */
+ private async loadFromFile(filename: string): Promise {
+ try {
+ const filePath = path.resolve(this.baseDirectory, filename);
+ const content = await fs.readFile(filePath, 'utf-8');
+ const structureMap = JSON.parse(content) as StructureMap;
+
+ // Basic validation
+ if (structureMap.resourceType !== 'StructureMap') {
+ throw new Error('Invalid StructureMap: resourceType must be "StructureMap"');
+ }
+
+ return structureMap;
+ } catch (error) {
+ console.error(`Error loading StructureMap from file ${filename}:`, error);
+ return null;
+ }
+ }
+
+ /**
+ * Load StructureMap from URL
+ */
+ private async loadFromUrl(url: string): Promise {
+ try {
+ // Note: Using fetch() available in Node.js 18+
+ // For older versions, would need to use a library like node-fetch
+ const response = await fetch(url);
+
+ if (!response.ok) {
+ throw new Error(`HTTP error! status: ${response.status}`);
+ }
+
+ const structureMap = await response.json() as StructureMap;
+
+ // Basic validation
+ if (structureMap.resourceType !== 'StructureMap') {
+ throw new Error('Invalid StructureMap: resourceType must be "StructureMap"');
+ }
+
+ return structureMap;
+ } catch (error) {
+ console.error(`Error loading StructureMap from URL ${url}:`, error);
+ return null;
+ }
+ }
+
+ /**
+ * Clear the cache
+ */
+ clearCache(): void {
+ this.cache.clear();
+ }
+
+ /**
+ * Set base directory for file loading
+ */
+ setBaseDirectory(directory: string): void {
+ this.baseDirectory = directory;
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/lib/validation-service.ts b/packages/fmlrunner/src/lib/validation-service.ts
new file mode 100644
index 0000000..4687f92
--- /dev/null
+++ b/packages/fmlrunner/src/lib/validation-service.ts
@@ -0,0 +1,197 @@
+import { StructureDefinition, ValidationResult, ValidationError, ValidationWarning } from '../types';
+import { Logger } from './logger';
+
+/**
+ * Basic validation service for FHIR resources
+ */
+export class ValidationService {
+ private structureDefinitions: Map = new Map();
+ private logger: Logger;
+
+ constructor(logger: Logger) {
+ this.logger = logger;
+ }
+
+ /**
+ * Register a StructureDefinition for validation
+ */
+ registerStructureDefinition(structureDefinition: StructureDefinition): void {
+ if (structureDefinition.url) {
+ this.structureDefinitions.set(structureDefinition.url, structureDefinition);
+ }
+ if (structureDefinition.name && structureDefinition.name !== structureDefinition.url) {
+ this.structureDefinitions.set(structureDefinition.name, structureDefinition);
+ }
+ }
+
+ /**
+ * Validate a resource against a StructureDefinition
+ */
+ validate(resource: any, profileUrl: string): ValidationResult {
+ const errors: ValidationError[] = [];
+ const warnings: ValidationWarning[] = [];
+
+ try {
+ const structureDefinition = this.structureDefinitions.get(profileUrl);
+
+ if (!structureDefinition) {
+ errors.push({
+ path: '',
+ message: `StructureDefinition not found: ${profileUrl}`,
+ severity: 'error'
+ });
+ return { valid: false, errors, warnings };
+ }
+
+ // Basic validation - check resource type matches
+ if (resource.resourceType && resource.resourceType !== structureDefinition.type) {
+ errors.push({
+ path: 'resourceType',
+ message: `Expected resourceType '${structureDefinition.type}', but got '${resource.resourceType}'`,
+ severity: 'error'
+ });
+ }
+
+ // Validate against snapshot elements if available
+ if (structureDefinition.snapshot?.element) {
+ this.validateElements(resource, structureDefinition.snapshot.element, structureDefinition.type, errors, warnings);
+ }
+
+ } catch (error) {
+ errors.push({
+ path: '',
+ message: `Validation error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+ severity: 'error'
+ });
+ }
+
+ return {
+ valid: errors.length === 0,
+ errors,
+ warnings
+ };
+ }
+
+ /**
+ * Validate resource elements against ElementDefinitions
+ */
+ private validateElements(
+ resource: any,
+ elements: any[],
+ resourceType: string,
+ errors: ValidationError[],
+ warnings: ValidationWarning[]
+ ): void {
+ for (const element of elements) {
+ if (!element.path) continue;
+
+ const elementPath = element.path;
+ const value = this.getValueAtPath(resource, elementPath, resourceType);
+
+ // Skip root element validation for now (it's the resource itself)
+ if (elementPath === resourceType) {
+ continue;
+ }
+
+ // Check cardinality
+ if (element.min !== undefined && element.min > 0) {
+ if (value === undefined || value === null) {
+ errors.push({
+ path: elementPath,
+ message: `Required element '${elementPath}' is missing (min: ${element.min})`,
+ severity: 'error'
+ });
+ }
+ }
+
+ if (element.max !== undefined && element.max !== '*') {
+ const maxValue = parseInt(element.max, 10);
+ if (Array.isArray(value) && value.length > maxValue) {
+ errors.push({
+ path: elementPath,
+ message: `Too many values for '${elementPath}' (max: ${element.max}, found: ${value.length})`,
+ severity: 'error'
+ });
+ }
+ }
+
+ // Basic type checking
+ if (value !== undefined && element.type && element.type.length > 0) {
+ const expectedType = element.type[0].code;
+ if (!this.isValidType(value, expectedType)) {
+ warnings.push({
+ path: elementPath,
+ message: `Value at '${elementPath}' may not match expected type '${expectedType}'`,
+ severity: 'warning'
+ });
+ }
+ }
+ }
+ }
+
+ /**
+ * Get value at a given FHIR path (simplified implementation)
+ */
+ private getValueAtPath(resource: any, path: string, resourceType?: string): any {
+ if (!path || !resource) return undefined;
+
+ // Handle root resource path
+ if (path === resourceType) {
+ return resource;
+ }
+
+ const parts = path.split('.');
+ let current = resource;
+
+ // Skip the resource type part if it's the first part
+ let startIndex = 0;
+ if (parts[0] === resourceType) {
+ startIndex = 1;
+ }
+
+ for (let i = startIndex; i < parts.length; i++) {
+ if (current === null || current === undefined) return undefined;
+ current = current[parts[i]];
+ }
+
+ return current;
+ }
+
+ /**
+ * Basic type validation
+ */
+ private isValidType(value: any, expectedType: string): boolean {
+ switch (expectedType) {
+ case 'string':
+ return typeof value === 'string';
+ case 'boolean':
+ return typeof value === 'boolean';
+ case 'integer':
+ case 'decimal':
+ return typeof value === 'number';
+ case 'date':
+ case 'dateTime':
+ return typeof value === 'string' && !isNaN(Date.parse(value));
+ case 'code':
+ case 'uri':
+ case 'url':
+ return typeof value === 'string';
+ default:
+ return true; // Unknown type, assume valid
+ }
+ }
+
+ /**
+ * Clear all registered StructureDefinitions
+ */
+ clearStructureDefinitions(): void {
+ this.structureDefinitions.clear();
+ }
+
+ /**
+ * Get all registered StructureDefinitions
+ */
+ getStructureDefinitions(): StructureDefinition[] {
+ return Array.from(this.structureDefinitions.values());
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/lib/valueset-service.ts b/packages/fmlrunner/src/lib/valueset-service.ts
new file mode 100644
index 0000000..ea4c7d5
--- /dev/null
+++ b/packages/fmlrunner/src/lib/valueset-service.ts
@@ -0,0 +1,252 @@
+import { ValueSet } from '../types';
+import { Logger } from './logger';
+
+/**
+ * Service for managing ValueSet resources
+ */
+export class ValueSetService {
+ private valueSets: Map = new Map();
+ private logger: Logger;
+
+ constructor(logger: Logger) {
+ this.logger = logger;
+ }
+
+ /**
+ * Register a ValueSet resource
+ */
+ registerValueSet(valueSet: ValueSet): void {
+ if (valueSet.id) {
+ this.valueSets.set(valueSet.id, valueSet);
+ }
+ if (valueSet.url) {
+ this.valueSets.set(valueSet.url, valueSet);
+ }
+ }
+
+ /**
+ * Get ValueSet by ID or URL
+ */
+ getValueSet(reference: string): ValueSet | null {
+ return this.valueSets.get(reference) || null;
+ }
+
+ /**
+ * Get all ValueSets
+ */
+ getAllValueSets(): ValueSet[] {
+ const unique = new Map();
+ this.valueSets.forEach((valueSet) => {
+ const key = valueSet.id || valueSet.url || Math.random().toString();
+ unique.set(key, valueSet);
+ });
+ return Array.from(unique.values());
+ }
+
+ /**
+ * Search ValueSets by parameters
+ */
+ searchValueSets(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ publisher?: string;
+ jurisdiction?: string;
+ }): ValueSet[] {
+ let results = this.getAllValueSets();
+
+ if (params.name) {
+ results = results.filter(vs =>
+ vs.name?.toLowerCase().includes(params.name!.toLowerCase()) ||
+ vs.title?.toLowerCase().includes(params.name!.toLowerCase())
+ );
+ }
+
+ if (params.status) {
+ results = results.filter(vs => vs.status === params.status);
+ }
+
+ if (params.url) {
+ results = results.filter(vs => vs.url === params.url);
+ }
+
+ if (params.publisher) {
+ results = results.filter(vs =>
+ vs.publisher?.toLowerCase().includes(params.publisher!.toLowerCase())
+ );
+ }
+
+ if (params.jurisdiction) {
+ results = results.filter(vs =>
+ vs.jurisdiction?.some(j =>
+ j.coding?.some(c => c.code === params.jurisdiction || c.display?.includes(params.jurisdiction!))
+ )
+ );
+ }
+
+ return results;
+ }
+
+ /**
+ * Remove ValueSet by ID or URL
+ */
+ removeValueSet(reference: string): boolean {
+ const valueSet = this.valueSets.get(reference);
+ if (valueSet) {
+ // Remove by both ID and URL if present
+ if (valueSet.id) {
+ this.valueSets.delete(valueSet.id);
+ }
+ if (valueSet.url) {
+ this.valueSets.delete(valueSet.url);
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Check if a code is in a ValueSet
+ */
+ validateCode(
+ valueSetRef: string,
+ system?: string,
+ code?: string,
+ display?: string
+ ): { result: boolean; message?: string } {
+ const valueSet = this.getValueSet(valueSetRef);
+ if (!valueSet) {
+ return { result: false, message: `ValueSet not found: ${valueSetRef}` };
+ }
+
+ // Check expanded codes first
+ if (valueSet.expansion?.contains) {
+ const found = this.findInExpansion(valueSet.expansion.contains, system, code, display);
+ if (found) {
+ return { result: true };
+ }
+ }
+
+ // Check compose includes
+ if (valueSet.compose?.include) {
+ for (const include of valueSet.compose.include) {
+ if (system && include.system && include.system !== system) {
+ continue;
+ }
+
+ // Check specific concepts
+ if (include.concept) {
+ for (const concept of include.concept) {
+ if (concept.code === code) {
+ if (!display || concept.display === display) {
+ return { result: true };
+ }
+ }
+ }
+ }
+
+ // If no specific concepts and system matches, assume code is valid
+ if (!include.concept && include.system === system && code) {
+ return { result: true };
+ }
+ }
+ }
+
+ return { result: false, message: `Code not found in ValueSet: ${code}` };
+ }
+
+ /**
+ * Helper method to search expansion
+ */
+ private findInExpansion(
+ contains: any[],
+ system?: string,
+ code?: string,
+ display?: string
+ ): boolean {
+ for (const item of contains) {
+ if (system && item.system && item.system !== system) {
+ continue;
+ }
+
+ if (item.code === code) {
+ if (!display || item.display === display) {
+ return true;
+ }
+ }
+
+ // Check nested contains
+ if (item.contains) {
+ if (this.findInExpansion(item.contains, system, code, display)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Expand a ValueSet (basic implementation)
+ */
+ expand(valueSetRef: string, count?: number, offset?: number): ValueSet | null {
+ const valueSet = this.getValueSet(valueSetRef);
+ if (!valueSet) {
+ return null;
+ }
+
+ // If already expanded, return as-is
+ if (valueSet.expansion) {
+ return valueSet;
+ }
+
+ // Basic expansion - would need code system lookup for full implementation
+ const expandedValueSet = { ...valueSet };
+ expandedValueSet.expansion = {
+ timestamp: new Date().toISOString(),
+ total: 0,
+ contains: []
+ };
+
+ if (valueSet.compose?.include) {
+ const allConcepts: any[] = [];
+ for (const include of valueSet.compose.include) {
+ if (include.concept) {
+ for (const concept of include.concept) {
+ allConcepts.push({
+ system: include.system,
+ code: concept.code,
+ display: concept.display
+ });
+ }
+ }
+ }
+
+ expandedValueSet.expansion.total = allConcepts.length;
+
+ if (offset) {
+ allConcepts.splice(0, offset);
+ }
+ if (count) {
+ allConcepts.splice(count);
+ }
+
+ expandedValueSet.expansion.contains = allConcepts;
+ }
+
+ return expandedValueSet;
+ }
+
+ /**
+ * Clear all ValueSets
+ */
+ clear(): void {
+ this.valueSets.clear();
+ }
+
+ /**
+ * Get count of registered ValueSets
+ */
+ getCount(): number {
+ return this.getAllValueSets().length;
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/structure-map-executor.ts b/packages/fmlrunner/src/structure-map-executor.ts
new file mode 100644
index 0000000..d3c686b
--- /dev/null
+++ b/packages/fmlrunner/src/structure-map-executor.ts
@@ -0,0 +1,422 @@
+import { StructureMap, ExecutionResult, ExecutionOptions, EnhancedExecutionResult } from './types';
+import { ValidationService } from './validation-service';
+import { ConceptMapService } from './conceptmap-service';
+import { ValueSetService } from './valueset-service';
+import { CodeSystemService } from './codesystem-service';
+import * as fhirpath from 'fhirpath';
+
+/**
+ * StructureMap execution engine - executes StructureMaps on input data
+ */
+export class StructureMapExecutor {
+ private validationService: ValidationService;
+ private conceptMapService?: ConceptMapService;
+ private valueSetService?: ValueSetService;
+ private codeSystemService?: CodeSystemService;
+
+ constructor() {
+ this.validationService = new ValidationService();
+ }
+
+ /**
+ * Set terminology services for advanced transformation support
+ */
+ setTerminologyServices(
+ conceptMapService: ConceptMapService,
+ valueSetService: ValueSetService,
+ codeSystemService: CodeSystemService
+ ): void {
+ this.conceptMapService = conceptMapService;
+ this.valueSetService = valueSetService;
+ this.codeSystemService = codeSystemService;
+ }
+
+ /**
+ * Execute a StructureMap on input content with optional validation
+ */
+ execute(structureMap: StructureMap, inputContent: any, options?: ExecutionOptions): EnhancedExecutionResult {
+ try {
+ // Basic validation
+ if (!structureMap) {
+ return {
+ success: false,
+ errors: ['StructureMap is required']
+ };
+ }
+
+ if (!structureMap.group || structureMap.group.length === 0) {
+ return {
+ success: false,
+ errors: ['StructureMap must have at least one group']
+ };
+ }
+
+ const result: EnhancedExecutionResult = {
+ success: true,
+ result: undefined,
+ validation: {}
+ };
+
+ // Validate input if requested
+ if (options?.validateInput && options?.inputProfile) {
+ const inputValidation = this.validationService.validate(inputContent, options.inputProfile);
+ result.validation!.input = inputValidation;
+
+ if (!inputValidation.valid && options?.strictMode) {
+ return {
+ success: false,
+ errors: [`Input validation failed: ${inputValidation.errors.map(e => e.message).join(', ')}`],
+ validation: result.validation
+ };
+ }
+ }
+
+ // Execute the main group
+ const mainGroup = structureMap.group.find(g => g.name === 'main') || structureMap.group[0];
+ const transformResult = this.executeGroup(mainGroup, inputContent);
+ result.result = transformResult;
+
+ // Validate output if requested
+ if (options?.validateOutput && options?.outputProfile) {
+ const outputValidation = this.validationService.validate(transformResult, options.outputProfile);
+ result.validation!.output = outputValidation;
+
+ if (!outputValidation.valid && options?.strictMode) {
+ return {
+ success: false,
+ errors: [`Output validation failed: ${outputValidation.errors.map(e => e.message).join(', ')}`],
+ validation: result.validation
+ };
+ }
+ }
+
+ return result;
+ } catch (error) {
+ return {
+ success: false,
+ errors: [error instanceof Error ? error.message : 'Unknown execution error']
+ };
+ }
+ }
+
+ /**
+ * Get the validation service for registering StructureDefinitions
+ */
+ getValidationService(): ValidationService {
+ return this.validationService;
+ }
+
+ /**
+ * Execute a group within a StructureMap
+ */
+ private executeGroup(group: any, inputContent: any): any {
+ // This is a basic implementation - a real StructureMap executor would be much more complex
+ // and would need to handle FHIR Path expressions, complex transformations, etc.
+
+ const result: any = {};
+
+ // Process each rule in the group
+ if (group.rule) {
+ for (const rule of group.rule) {
+ this.executeRule(rule, inputContent, result);
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Execute a single mapping rule
+ */
+ private executeRule(rule: any, source: any, target: any): void {
+ try {
+ // Basic rule execution - map simple element to element
+ if (rule.source && rule.target && rule.source.length > 0 && rule.target.length > 0) {
+ const sourceElement = rule.source[0].element;
+ const targetElement = rule.target[0].element;
+
+ if (sourceElement && targetElement && source[sourceElement] !== undefined) {
+ let value = source[sourceElement];
+
+ // Check if target has transform operations
+ const targetRule = rule.target[0];
+ if (targetRule.transform) {
+ value = this.applyTransform(targetRule.transform, value, targetRule.parameter);
+ }
+
+ target[targetElement] = value;
+ }
+ }
+ } catch (error) {
+ console.error('Error executing rule:', error);
+ }
+ }
+
+ /**
+ * Apply transform operations including terminology operations
+ */
+ private applyTransform(transform: string, value: any, parameters?: any[]): any {
+ switch (transform) {
+ case 'copy':
+ return value;
+
+ case 'translate':
+ return this.applyTranslateTransform(value, parameters);
+
+ case 'evaluate':
+ // FHIRPath evaluation - basic implementation
+ return this.evaluateFhirPath(value, parameters);
+
+ case 'create':
+ // Create a new resource/element
+ return this.createResource(parameters);
+
+ case 'reference':
+ // Create a reference
+ return this.createReference(value, parameters);
+
+ case 'dateOp':
+ // Date operations
+ return this.applyDateOperation(value, parameters);
+
+ case 'append':
+ // String append operation
+ return this.appendStrings(value, parameters);
+
+ case 'cast':
+ // Type casting
+ return this.castValue(value, parameters);
+
+ default:
+ console.warn(`Unknown transform: ${transform}`);
+ return value;
+ }
+ }
+
+ /**
+ * Apply translate transform using ConceptMaps
+ */
+ private applyTranslateTransform(value: any, parameters?: any[]): any {
+ if (!this.conceptMapService || !parameters || parameters.length < 2) {
+ return value;
+ }
+
+ try {
+ const sourceSystem = parameters[0];
+ const targetSystem = parameters[1];
+
+ if (typeof value === 'object' && value.code && value.system) {
+ // Handle Coding input
+ const translations = this.conceptMapService.translate(
+ value.system,
+ value.code,
+ targetSystem
+ );
+
+ if (translations.length > 0) {
+ const translation = translations[0];
+ return {
+ system: translation.system || targetSystem,
+ code: translation.code,
+ display: translation.display
+ };
+ }
+ } else if (typeof value === 'string') {
+ // Handle string code input
+ const translations = this.conceptMapService.translate(
+ sourceSystem,
+ value,
+ targetSystem
+ );
+
+ if (translations.length > 0) {
+ return translations[0].code;
+ }
+ }
+ } catch (error) {
+ console.error('Error in translate transform:', error);
+ }
+
+ return value;
+ }
+
+ /**
+ * FHIRPath evaluation using official HL7 FHIRPath library
+ */
+ private evaluateFhirPath(value: any, parameters?: any[]): any {
+ if (!parameters || parameters.length === 0) {
+ return value;
+ }
+
+ const expression = parameters[0];
+
+ try {
+ // Use the official HL7 FHIRPath library for proper evaluation
+ const result = fhirpath.evaluate(value, expression);
+
+ // FHIRPath returns an array of results, return first result or empty array
+ if (Array.isArray(result)) {
+ return result.length === 1 ? result[0] : result;
+ }
+
+ return result;
+ } catch (error) {
+ console.error(`FHIRPath evaluation failed for expression "${expression}":`, error);
+ // Return undefined for failed evaluations rather than partial results
+ return undefined;
+ }
+ }
+
+ /**
+ * Create a new resource or element
+ */
+ private createResource(parameters?: any[]): any {
+ if (!parameters || parameters.length === 0) {
+ return {};
+ }
+
+ const resourceType = parameters[0];
+ return { resourceType };
+ }
+
+ /**
+ * Create a reference
+ */
+ private createReference(value: any, parameters?: any[]): any {
+ if (typeof value === 'string') {
+ return { reference: value };
+ }
+
+ if (value && value.resourceType && value.id) {
+ return { reference: `${value.resourceType}/${value.id}` };
+ }
+
+ return value;
+ }
+
+ /**
+ * Apply date operations
+ */
+ private applyDateOperation(value: any, parameters?: any[]): any {
+ if (!parameters || parameters.length < 2) {
+ return value;
+ }
+
+ const operation = parameters[0];
+ const amount = parameters[1];
+
+ try {
+ const date = new Date(value);
+
+ switch (operation) {
+ case 'add':
+ return new Date(date.getTime() + amount * 24 * 60 * 60 * 1000).toISOString();
+ case 'subtract':
+ return new Date(date.getTime() - amount * 24 * 60 * 60 * 1000).toISOString();
+ case 'now':
+ return new Date().toISOString();
+ default:
+ return value;
+ }
+ } catch (error) {
+ return value;
+ }
+ }
+
+ /**
+ * Append strings
+ */
+ private appendStrings(value: any, parameters?: any[]): any {
+ if (!parameters || parameters.length === 0) {
+ return value;
+ }
+
+ let result = String(value || '');
+ for (const param of parameters) {
+ result += String(param);
+ }
+
+ return result;
+ }
+
+ /**
+ * Cast value to different type
+ */
+ private castValue(value: any, parameters?: any[]): any {
+ if (!parameters || parameters.length === 0) {
+ return value;
+ }
+
+ const targetType = parameters[0];
+
+ try {
+ switch (targetType) {
+ case 'string':
+ return String(value);
+ case 'integer':
+ return parseInt(value, 10);
+ case 'decimal':
+ return parseFloat(value);
+ case 'boolean':
+ return Boolean(value);
+ case 'date':
+ return new Date(value).toISOString().split('T')[0];
+ case 'dateTime':
+ return new Date(value).toISOString();
+ default:
+ return value;
+ }
+ } catch (error) {
+ return value;
+ }
+ }
+
+ /**
+ * Get terminology services for external access
+ */
+ getTerminologyServices(): {
+ conceptMapService?: ConceptMapService;
+ valueSetService?: ValueSetService;
+ codeSystemService?: CodeSystemService;
+ } {
+ return {
+ conceptMapService: this.conceptMapService,
+ valueSetService: this.valueSetService,
+ codeSystemService: this.codeSystemService
+ };
+ }
+
+ /**
+ * Validate that a StructureMap can be executed
+ */
+ validateStructureMap(structureMap: StructureMap): { valid: boolean; errors: string[] } {
+ const errors: string[] = [];
+
+ if (!structureMap) {
+ errors.push('StructureMap is null or undefined');
+ return { valid: false, errors };
+ }
+
+ if (structureMap.resourceType !== 'StructureMap') {
+ errors.push('Resource type must be "StructureMap"');
+ }
+
+ if (!structureMap.group || structureMap.group.length === 0) {
+ errors.push('StructureMap must have at least one group');
+ }
+
+ if (structureMap.group) {
+ for (let i = 0; i < structureMap.group.length; i++) {
+ const group = structureMap.group[i];
+ if (!group.name) {
+ errors.push(`Group ${i} must have a name`);
+ }
+ if (!group.input || group.input.length === 0) {
+ errors.push(`Group ${i} must have at least one input`);
+ }
+ }
+ }
+
+ return { valid: errors.length === 0, errors };
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/structure-map-retriever.ts b/packages/fmlrunner/src/structure-map-retriever.ts
new file mode 100644
index 0000000..3329f22
--- /dev/null
+++ b/packages/fmlrunner/src/structure-map-retriever.ts
@@ -0,0 +1,109 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { StructureMap } from './types';
+
+/**
+ * StructureMap retrieval service - loads StructureMaps from files or URLs
+ */
+export class StructureMapRetriever {
+ private baseDirectory: string;
+ private cache: Map = new Map();
+
+ constructor(baseDirectory: string = './maps') {
+ this.baseDirectory = baseDirectory;
+ }
+
+ /**
+ * Retrieve StructureMap by reference (file path or URL)
+ */
+ async getStructureMap(reference: string): Promise {
+ try {
+ // Check cache first
+ if (this.cache.has(reference)) {
+ return this.cache.get(reference) || null;
+ }
+
+ let structureMap: StructureMap | null = null;
+
+ if (reference.startsWith('http')) {
+ // Load from URL
+ structureMap = await this.loadFromUrl(reference);
+ } else {
+ // Load from file
+ structureMap = await this.loadFromFile(reference);
+ }
+
+ // Cache the result
+ if (structureMap) {
+ this.cache.set(reference, structureMap);
+ }
+
+ return structureMap;
+ } catch (error) {
+ console.error(`Error retrieving StructureMap ${reference}:`, error);
+ return null;
+ }
+ }
+
+ /**
+ * Load StructureMap from local file
+ */
+ private async loadFromFile(filename: string): Promise {
+ try {
+ const filePath = path.resolve(this.baseDirectory, filename);
+ const content = await fs.readFile(filePath, 'utf-8');
+ const structureMap = JSON.parse(content) as StructureMap;
+
+ // Basic validation
+ if (structureMap.resourceType !== 'StructureMap') {
+ throw new Error('Invalid StructureMap: resourceType must be "StructureMap"');
+ }
+
+ return structureMap;
+ } catch (error) {
+ console.error(`Error loading StructureMap from file ${filename}:`, error);
+ return null;
+ }
+ }
+
+ /**
+ * Load StructureMap from URL
+ */
+ private async loadFromUrl(url: string): Promise {
+ try {
+ // Note: Using fetch() available in Node.js 18+
+ // For older versions, would need to use a library like node-fetch
+ const response = await fetch(url);
+
+ if (!response.ok) {
+ throw new Error(`HTTP error! status: ${response.status}`);
+ }
+
+ const structureMap = await response.json() as StructureMap;
+
+ // Basic validation
+ if (structureMap.resourceType !== 'StructureMap') {
+ throw new Error('Invalid StructureMap: resourceType must be "StructureMap"');
+ }
+
+ return structureMap;
+ } catch (error) {
+ console.error(`Error loading StructureMap from URL ${url}:`, error);
+ return null;
+ }
+ }
+
+ /**
+ * Clear the cache
+ */
+ clearCache(): void {
+ this.cache.clear();
+ }
+
+ /**
+ * Set base directory for file loading
+ */
+ setBaseDirectory(directory: string): void {
+ this.baseDirectory = directory;
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/types/fhirpath.d.ts b/packages/fmlrunner/src/types/fhirpath.d.ts
new file mode 100644
index 0000000..51c8ef9
--- /dev/null
+++ b/packages/fmlrunner/src/types/fhirpath.d.ts
@@ -0,0 +1,37 @@
+declare module 'fhirpath' {
+ /**
+ * Evaluate a FHIRPath expression against a resource
+ * @param resource - The FHIR resource or data to evaluate against
+ * @param expression - The FHIRPath expression to evaluate
+ * @param context - Optional context for the evaluation
+ * @returns Array of results from the evaluation
+ */
+ export function evaluate(resource: any, expression: string, context?: any): any[];
+
+ /**
+ * Parse a FHIRPath expression into an AST
+ * @param expression - The FHIRPath expression to parse
+ * @returns Parsed AST
+ */
+ export function parse(expression: string): any;
+
+ /**
+ * Compile a FHIRPath expression for faster repeated evaluation
+ * @param expression - The FHIRPath expression to compile
+ * @returns Compiled expression function
+ */
+ export function compile(expression: string): (resource: any, context?: any) => any[];
+
+ /**
+ * Library version
+ */
+ export const version: string;
+
+ /**
+ * Utility functions
+ */
+ export const util: any;
+ export const types: any;
+ export const ucumUtils: any;
+ export const resolveInternalTypes: any;
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/types/index.ts b/packages/fmlrunner/src/types/index.ts
new file mode 100644
index 0000000..d03bbf7
--- /dev/null
+++ b/packages/fmlrunner/src/types/index.ts
@@ -0,0 +1,537 @@
+/**
+ * Basic FHIR StructureMap types
+ */
+
+export interface StructureMap {
+ resourceType: 'StructureMap';
+ id?: string;
+ url?: string;
+ name?: string;
+ title?: string;
+ status: 'draft' | 'active' | 'retired' | 'unknown';
+ experimental?: boolean;
+ description?: string;
+ group: StructureMapGroup[];
+}
+
+export interface StructureMapGroup {
+ name: string;
+ typeMode?: 'none' | 'types' | 'type-and-types';
+ documentation?: string;
+ input: StructureMapGroupInput[];
+ rule: StructureMapGroupRule[];
+}
+
+export interface StructureMapGroupInput {
+ name: string;
+ type?: string;
+ mode: 'source' | 'target';
+ documentation?: string;
+}
+
+export interface StructureMapGroupRule {
+ name?: string;
+ source: StructureMapGroupRuleSource[];
+ target?: StructureMapGroupRuleTarget[];
+ documentation?: string;
+}
+
+export interface StructureMapGroupRuleSource {
+ context: string;
+ element?: string;
+ variable?: string;
+ type?: string;
+ min?: number;
+ max?: string;
+}
+
+export interface StructureMapGroupRuleTarget {
+ context?: string;
+ contextType?: 'variable' | 'type';
+ element?: string;
+ variable?: string;
+ transform?: string;
+ parameter?: any[];
+}
+
+/**
+ * FML compilation result
+ */
+export interface FmlCompilationResult {
+ success: boolean;
+ structureMap?: StructureMap;
+ errors?: string[];
+}
+
+/**
+ * StructureMap execution result
+ */
+export interface ExecutionResult {
+ success: boolean;
+ result?: any;
+ errors?: string[];
+}
+
+/**
+ * Configuration options
+ */
+export interface FmlRunnerOptions {
+ baseUrl?: string;
+ cacheEnabled?: boolean;
+ timeout?: number;
+ strictMode?: boolean; // Enable strict validation mode
+ validateInputOutput?: boolean; // Enable JSON schema validation for all input/output
+ disableValidation?: boolean; // Explicitly disable validation
+ logLevel?: 'error' | 'warn' | 'info' | 'debug' | 'verbose' | 'silly'; // Logging level
+}
+
+/**
+ * FHIR StructureDefinition for logical models and validation
+ */
+export interface StructureDefinition {
+ resourceType: 'StructureDefinition';
+ id?: string;
+ url?: string;
+ name?: string;
+ title?: string;
+ status: 'draft' | 'active' | 'retired' | 'unknown';
+ kind: 'primitive-type' | 'complex-type' | 'resource' | 'logical';
+ abstract?: boolean;
+ type: string;
+ baseDefinition?: string;
+ derivation?: 'specialization' | 'constraint';
+ snapshot?: StructureDefinitionSnapshot;
+ differential?: StructureDefinitionDifferential;
+}
+
+export interface StructureDefinitionSnapshot {
+ element: ElementDefinition[];
+}
+
+export interface StructureDefinitionDifferential {
+ element: ElementDefinition[];
+}
+
+export interface ElementDefinition {
+ id?: string;
+ path: string;
+ sliceName?: string;
+ min?: number;
+ max?: string;
+ type?: ElementDefinitionType[];
+ binding?: ElementDefinitionBinding;
+}
+
+export interface ElementDefinitionType {
+ code: string;
+ profile?: string[];
+}
+
+export interface ElementDefinitionBinding {
+ strength?: 'required' | 'extensible' | 'preferred' | 'example';
+ valueSet?: string;
+}
+
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+ valid: boolean;
+ errors: ValidationError[];
+ warnings: ValidationWarning[];
+}
+
+export interface ValidationError {
+ path: string;
+ message: string;
+ severity: 'error';
+}
+
+export interface ValidationWarning {
+ path: string;
+ message: string;
+ severity: 'warning';
+}
+
+/**
+ * Enhanced execution options with validation
+ */
+export interface ExecutionOptions {
+ strictMode?: boolean;
+ validateInput?: boolean;
+ validateOutput?: boolean;
+ inputProfile?: string;
+ outputProfile?: string;
+}
+
+/**
+ * Enhanced execution result with validation details
+ */
+export interface EnhancedExecutionResult extends ExecutionResult {
+ validation?: {
+ input?: ValidationResult;
+ output?: ValidationResult;
+ };
+}
+
+/**
+ * FHIR ConceptMap resource for terminology mapping
+ */
+export interface ConceptMap {
+ resourceType: 'ConceptMap';
+ id?: string;
+ url?: string;
+ identifier?: Identifier[];
+ version?: string;
+ name?: string;
+ title?: string;
+ status: 'draft' | 'active' | 'retired' | 'unknown';
+ experimental?: boolean;
+ date?: string;
+ publisher?: string;
+ contact?: ContactDetail[];
+ description?: string;
+ useContext?: UsageContext[];
+ jurisdiction?: CodeableConcept[];
+ purpose?: string;
+ copyright?: string;
+ sourceUri?: string;
+ sourceCanonical?: string;
+ targetUri?: string;
+ targetCanonical?: string;
+ group?: ConceptMapGroup[];
+}
+
+export interface ConceptMapGroup {
+ source?: string;
+ sourceVersion?: string;
+ target?: string;
+ targetVersion?: string;
+ element: ConceptMapGroupElement[];
+ unmapped?: ConceptMapGroupUnmapped;
+}
+
+export interface ConceptMapGroupElement {
+ code?: string;
+ display?: string;
+ target?: ConceptMapGroupElementTarget[];
+}
+
+export interface ConceptMapGroupElementTarget {
+ code?: string;
+ display?: string;
+ equivalence: 'relatedto' | 'equivalent' | 'equal' | 'wider' | 'subsumes' | 'narrower' | 'specializes' | 'inexact' | 'unmatched' | 'disjoint';
+ comment?: string;
+ dependsOn?: ConceptMapGroupElementTargetDependsOn[];
+ product?: ConceptMapGroupElementTargetDependsOn[];
+}
+
+export interface ConceptMapGroupElementTargetDependsOn {
+ property: string;
+ system?: string;
+ value: string;
+ display?: string;
+}
+
+export interface ConceptMapGroupUnmapped {
+ mode: 'provided' | 'fixed' | 'other-map';
+ code?: string;
+ display?: string;
+ url?: string;
+}
+
+/**
+ * FHIR ValueSet resource for terminology sets
+ */
+export interface ValueSet {
+ resourceType: 'ValueSet';
+ id?: string;
+ url?: string;
+ identifier?: Identifier[];
+ version?: string;
+ name?: string;
+ title?: string;
+ status: 'draft' | 'active' | 'retired' | 'unknown';
+ experimental?: boolean;
+ date?: string;
+ publisher?: string;
+ contact?: ContactDetail[];
+ description?: string;
+ useContext?: UsageContext[];
+ jurisdiction?: CodeableConcept[];
+ immutable?: boolean;
+ purpose?: string;
+ copyright?: string;
+ compose?: ValueSetCompose;
+ expansion?: ValueSetExpansion;
+}
+
+export interface ValueSetCompose {
+ lockedDate?: string;
+ inactive?: boolean;
+ include: ValueSetComposeInclude[];
+ exclude?: ValueSetComposeInclude[];
+}
+
+export interface ValueSetComposeInclude {
+ system?: string;
+ version?: string;
+ concept?: ValueSetComposeIncludeConcept[];
+ filter?: ValueSetComposeIncludeFilter[];
+ valueSet?: string[];
+}
+
+export interface ValueSetComposeIncludeConcept {
+ code: string;
+ display?: string;
+ designation?: ValueSetComposeIncludeConceptDesignation[];
+}
+
+export interface ValueSetComposeIncludeConceptDesignation {
+ language?: string;
+ use?: Coding;
+ value: string;
+}
+
+export interface ValueSetComposeIncludeFilter {
+ property: string;
+ op: 'equals' | 'is-a' | 'descendent-of' | 'is-not-a' | 'regex' | 'in' | 'not-in' | 'generalizes' | 'exists';
+ value: string;
+}
+
+export interface ValueSetExpansion {
+ identifier?: string;
+ timestamp: string;
+ total?: number;
+ offset?: number;
+ parameter?: ValueSetExpansionParameter[];
+ contains?: ValueSetExpansionContains[];
+}
+
+export interface ValueSetExpansionParameter {
+ name: string;
+ valueString?: string;
+ valueBoolean?: boolean;
+ valueInteger?: number;
+ valueDecimal?: number;
+ valueUri?: string;
+ valueCode?: string;
+ valueDateTime?: string;
+}
+
+export interface ValueSetExpansionContains {
+ system?: string;
+ abstract?: boolean;
+ inactive?: boolean;
+ version?: string;
+ code?: string;
+ display?: string;
+ designation?: ValueSetComposeIncludeConceptDesignation[];
+ contains?: ValueSetExpansionContains[];
+}
+
+/**
+ * FHIR CodeSystem resource for terminology definitions
+ */
+export interface CodeSystem {
+ resourceType: 'CodeSystem';
+ id?: string;
+ url?: string;
+ identifier?: Identifier[];
+ version?: string;
+ name?: string;
+ title?: string;
+ status: 'draft' | 'active' | 'retired' | 'unknown';
+ experimental?: boolean;
+ date?: string;
+ publisher?: string;
+ contact?: ContactDetail[];
+ description?: string;
+ useContext?: UsageContext[];
+ jurisdiction?: CodeableConcept[];
+ purpose?: string;
+ copyright?: string;
+ caseSensitive?: boolean;
+ valueSet?: string;
+ hierarchyMeaning?: 'grouped-by' | 'is-a' | 'part-of' | 'classified-with';
+ compositional?: boolean;
+ versionNeeded?: boolean;
+ content: 'not-present' | 'example' | 'fragment' | 'complete' | 'supplement';
+ supplements?: string;
+ count?: number;
+ filter?: CodeSystemFilter[];
+ property?: CodeSystemProperty[];
+ concept?: CodeSystemConcept[];
+}
+
+export interface CodeSystemFilter {
+ code: string;
+ description?: string;
+ operator: ('equals' | 'is-a' | 'descendent-of' | 'is-not-a' | 'regex' | 'in' | 'not-in' | 'generalizes' | 'exists')[];
+ value: string;
+}
+
+export interface CodeSystemProperty {
+ code: string;
+ uri?: string;
+ description?: string;
+ type: 'code' | 'Coding' | 'string' | 'integer' | 'boolean' | 'dateTime' | 'decimal';
+}
+
+export interface CodeSystemConcept {
+ code: string;
+ display?: string;
+ definition?: string;
+ designation?: CodeSystemConceptDesignation[];
+ property?: CodeSystemConceptProperty[];
+ concept?: CodeSystemConcept[];
+}
+
+export interface CodeSystemConceptDesignation {
+ language?: string;
+ use?: Coding;
+ value: string;
+}
+
+export interface CodeSystemConceptProperty {
+ code: string;
+ valueCode?: string;
+ valueCoding?: Coding;
+ valueString?: string;
+ valueInteger?: number;
+ valueBoolean?: boolean;
+ valueDateTime?: string;
+ valueDecimal?: number;
+}
+
+/**
+ * Common FHIR data types
+ */
+export interface Identifier {
+ use?: 'usual' | 'official' | 'temp' | 'secondary' | 'old';
+ type?: CodeableConcept;
+ system?: string;
+ value?: string;
+ period?: Period;
+ assigner?: Reference;
+}
+
+export interface ContactDetail {
+ name?: string;
+ telecom?: ContactPoint[];
+}
+
+export interface ContactPoint {
+ system?: 'phone' | 'fax' | 'email' | 'pager' | 'url' | 'sms' | 'other';
+ value?: string;
+ use?: 'home' | 'work' | 'temp' | 'old' | 'mobile';
+ rank?: number;
+ period?: Period;
+}
+
+export interface UsageContext {
+ code: Coding;
+ valueCodeableConcept?: CodeableConcept;
+ valueQuantity?: Quantity;
+ valueRange?: Range;
+ valueReference?: Reference;
+}
+
+export interface CodeableConcept {
+ coding?: Coding[];
+ text?: string;
+}
+
+export interface Coding {
+ system?: string;
+ version?: string;
+ code?: string;
+ display?: string;
+ userSelected?: boolean;
+}
+
+export interface Period {
+ start?: string;
+ end?: string;
+}
+
+export interface Reference {
+ reference?: string;
+ type?: string;
+ identifier?: Identifier;
+ display?: string;
+}
+
+export interface Quantity {
+ value?: number;
+ comparator?: '<' | '<=' | '>=' | '>';
+ unit?: string;
+ system?: string;
+ code?: string;
+}
+
+export interface Range {
+ low?: Quantity;
+ high?: Quantity;
+}
+
+/**
+ * FHIR Bundle for bulk operations
+ */
+export interface Bundle {
+ resourceType: 'Bundle';
+ id?: string;
+ identifier?: Identifier;
+ type: 'document' | 'message' | 'transaction' | 'transaction-response' | 'batch' | 'batch-response' | 'history' | 'searchset' | 'collection';
+ timestamp?: string;
+ total?: number;
+ link?: BundleLink[];
+ entry?: BundleEntry[];
+ signature?: Signature;
+}
+
+export interface BundleLink {
+ relation: string;
+ url: string;
+}
+
+export interface BundleEntry {
+ link?: BundleLink[];
+ fullUrl?: string;
+ resource?: any; // Can be any FHIR resource
+ search?: BundleEntrySearch;
+ request?: BundleEntryRequest;
+ response?: BundleEntryResponse;
+}
+
+export interface BundleEntrySearch {
+ mode?: 'match' | 'include' | 'outcome';
+ score?: number;
+}
+
+export interface BundleEntryRequest {
+ method: 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+ url: string;
+ ifNoneMatch?: string;
+ ifModifiedSince?: string;
+ ifMatch?: string;
+ ifNoneExist?: string;
+}
+
+export interface BundleEntryResponse {
+ status: string;
+ location?: string;
+ etag?: string;
+ lastModified?: string;
+ outcome?: any;
+}
+
+export interface Signature {
+ type: Coding[];
+ when: string;
+ who: Reference;
+ onBehalfOf?: Reference;
+ targetFormat?: string;
+ sigFormat?: string;
+ data?: string;
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/validation-service.ts b/packages/fmlrunner/src/validation-service.ts
new file mode 100644
index 0000000..80d452f
--- /dev/null
+++ b/packages/fmlrunner/src/validation-service.ts
@@ -0,0 +1,191 @@
+import { StructureDefinition, ValidationResult, ValidationError, ValidationWarning } from './types';
+
+/**
+ * Basic validation service for FHIR resources
+ */
+export class ValidationService {
+ private structureDefinitions: Map = new Map();
+
+ /**
+ * Register a StructureDefinition for validation
+ */
+ registerStructureDefinition(structureDefinition: StructureDefinition): void {
+ if (structureDefinition.url) {
+ this.structureDefinitions.set(structureDefinition.url, structureDefinition);
+ }
+ if (structureDefinition.name && structureDefinition.name !== structureDefinition.url) {
+ this.structureDefinitions.set(structureDefinition.name, structureDefinition);
+ }
+ }
+
+ /**
+ * Validate a resource against a StructureDefinition
+ */
+ validate(resource: any, profileUrl: string): ValidationResult {
+ const errors: ValidationError[] = [];
+ const warnings: ValidationWarning[] = [];
+
+ try {
+ const structureDefinition = this.structureDefinitions.get(profileUrl);
+
+ if (!structureDefinition) {
+ errors.push({
+ path: '',
+ message: `StructureDefinition not found: ${profileUrl}`,
+ severity: 'error'
+ });
+ return { valid: false, errors, warnings };
+ }
+
+ // Basic validation - check resource type matches
+ if (resource.resourceType && resource.resourceType !== structureDefinition.type) {
+ errors.push({
+ path: 'resourceType',
+ message: `Expected resourceType '${structureDefinition.type}', but got '${resource.resourceType}'`,
+ severity: 'error'
+ });
+ }
+
+ // Validate against snapshot elements if available
+ if (structureDefinition.snapshot?.element) {
+ this.validateElements(resource, structureDefinition.snapshot.element, structureDefinition.type, errors, warnings);
+ }
+
+ } catch (error) {
+ errors.push({
+ path: '',
+ message: `Validation error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+ severity: 'error'
+ });
+ }
+
+ return {
+ valid: errors.length === 0,
+ errors,
+ warnings
+ };
+ }
+
+ /**
+ * Validate resource elements against ElementDefinitions
+ */
+ private validateElements(
+ resource: any,
+ elements: any[],
+ resourceType: string,
+ errors: ValidationError[],
+ warnings: ValidationWarning[]
+ ): void {
+ for (const element of elements) {
+ if (!element.path) continue;
+
+ const elementPath = element.path;
+ const value = this.getValueAtPath(resource, elementPath, resourceType);
+
+ // Skip root element validation for now (it's the resource itself)
+ if (elementPath === resourceType) {
+ continue;
+ }
+
+ // Check cardinality
+ if (element.min !== undefined && element.min > 0) {
+ if (value === undefined || value === null) {
+ errors.push({
+ path: elementPath,
+ message: `Required element '${elementPath}' is missing (min: ${element.min})`,
+ severity: 'error'
+ });
+ }
+ }
+
+ if (element.max !== undefined && element.max !== '*') {
+ const maxValue = parseInt(element.max, 10);
+ if (Array.isArray(value) && value.length > maxValue) {
+ errors.push({
+ path: elementPath,
+ message: `Too many values for '${elementPath}' (max: ${element.max}, found: ${value.length})`,
+ severity: 'error'
+ });
+ }
+ }
+
+ // Basic type checking
+ if (value !== undefined && element.type && element.type.length > 0) {
+ const expectedType = element.type[0].code;
+ if (!this.isValidType(value, expectedType)) {
+ warnings.push({
+ path: elementPath,
+ message: `Value at '${elementPath}' may not match expected type '${expectedType}'`,
+ severity: 'warning'
+ });
+ }
+ }
+ }
+ }
+
+ /**
+ * Get value at a given FHIR path (simplified implementation)
+ */
+ private getValueAtPath(resource: any, path: string, resourceType?: string): any {
+ if (!path || !resource) return undefined;
+
+ // Handle root resource path
+ if (path === resourceType) {
+ return resource;
+ }
+
+ const parts = path.split('.');
+ let current = resource;
+
+ // Skip the resource type part if it's the first part
+ let startIndex = 0;
+ if (parts[0] === resourceType) {
+ startIndex = 1;
+ }
+
+ for (let i = startIndex; i < parts.length; i++) {
+ if (current === null || current === undefined) return undefined;
+ current = current[parts[i]];
+ }
+
+ return current;
+ }
+
+ /**
+ * Basic type validation
+ */
+ private isValidType(value: any, expectedType: string): boolean {
+ switch (expectedType) {
+ case 'string':
+ return typeof value === 'string';
+ case 'boolean':
+ return typeof value === 'boolean';
+ case 'integer':
+ case 'decimal':
+ return typeof value === 'number';
+ case 'date':
+ case 'dateTime':
+ return typeof value === 'string' && !isNaN(Date.parse(value));
+ case 'code':
+ case 'uri':
+ case 'url':
+ return typeof value === 'string';
+ default:
+ return true; // Unknown type, assume valid
+ }
+ }
+
+ /**
+ * Clear all registered StructureDefinitions
+ */
+ clearStructureDefinitions(): void {
+ this.structureDefinitions.clear();
+ }
+
+ /**
+ * Get all registered StructureDefinitions
+ */
+ getStructureDefinitions(): StructureDefinition[] {
+ return Array.from(this.structureDefinitions.values());
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/src/valueset-service.ts b/packages/fmlrunner/src/valueset-service.ts
new file mode 100644
index 0000000..63cc1c7
--- /dev/null
+++ b/packages/fmlrunner/src/valueset-service.ts
@@ -0,0 +1,246 @@
+import { ValueSet } from './types';
+
+/**
+ * Service for managing ValueSet resources
+ */
+export class ValueSetService {
+ private valueSets: Map = new Map();
+
+ /**
+ * Register a ValueSet resource
+ */
+ registerValueSet(valueSet: ValueSet): void {
+ if (valueSet.id) {
+ this.valueSets.set(valueSet.id, valueSet);
+ }
+ if (valueSet.url) {
+ this.valueSets.set(valueSet.url, valueSet);
+ }
+ }
+
+ /**
+ * Get ValueSet by ID or URL
+ */
+ getValueSet(reference: string): ValueSet | null {
+ return this.valueSets.get(reference) || null;
+ }
+
+ /**
+ * Get all ValueSets
+ */
+ getAllValueSets(): ValueSet[] {
+ const unique = new Map();
+ this.valueSets.forEach((valueSet) => {
+ const key = valueSet.id || valueSet.url || Math.random().toString();
+ unique.set(key, valueSet);
+ });
+ return Array.from(unique.values());
+ }
+
+ /**
+ * Search ValueSets by parameters
+ */
+ searchValueSets(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ publisher?: string;
+ jurisdiction?: string;
+ }): ValueSet[] {
+ let results = this.getAllValueSets();
+
+ if (params.name) {
+ results = results.filter(vs =>
+ vs.name?.toLowerCase().includes(params.name!.toLowerCase()) ||
+ vs.title?.toLowerCase().includes(params.name!.toLowerCase())
+ );
+ }
+
+ if (params.status) {
+ results = results.filter(vs => vs.status === params.status);
+ }
+
+ if (params.url) {
+ results = results.filter(vs => vs.url === params.url);
+ }
+
+ if (params.publisher) {
+ results = results.filter(vs =>
+ vs.publisher?.toLowerCase().includes(params.publisher!.toLowerCase())
+ );
+ }
+
+ if (params.jurisdiction) {
+ results = results.filter(vs =>
+ vs.jurisdiction?.some(j =>
+ j.coding?.some(c => c.code === params.jurisdiction || c.display?.includes(params.jurisdiction!))
+ )
+ );
+ }
+
+ return results;
+ }
+
+ /**
+ * Remove ValueSet by ID or URL
+ */
+ removeValueSet(reference: string): boolean {
+ const valueSet = this.valueSets.get(reference);
+ if (valueSet) {
+ // Remove by both ID and URL if present
+ if (valueSet.id) {
+ this.valueSets.delete(valueSet.id);
+ }
+ if (valueSet.url) {
+ this.valueSets.delete(valueSet.url);
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Check if a code is in a ValueSet
+ */
+ validateCode(
+ valueSetRef: string,
+ system?: string,
+ code?: string,
+ display?: string
+ ): { result: boolean; message?: string } {
+ const valueSet = this.getValueSet(valueSetRef);
+ if (!valueSet) {
+ return { result: false, message: `ValueSet not found: ${valueSetRef}` };
+ }
+
+ // Check expanded codes first
+ if (valueSet.expansion?.contains) {
+ const found = this.findInExpansion(valueSet.expansion.contains, system, code, display);
+ if (found) {
+ return { result: true };
+ }
+ }
+
+ // Check compose includes
+ if (valueSet.compose?.include) {
+ for (const include of valueSet.compose.include) {
+ if (system && include.system && include.system !== system) {
+ continue;
+ }
+
+ // Check specific concepts
+ if (include.concept) {
+ for (const concept of include.concept) {
+ if (concept.code === code) {
+ if (!display || concept.display === display) {
+ return { result: true };
+ }
+ }
+ }
+ }
+
+ // If no specific concepts and system matches, assume code is valid
+ if (!include.concept && include.system === system && code) {
+ return { result: true };
+ }
+ }
+ }
+
+ return { result: false, message: `Code not found in ValueSet: ${code}` };
+ }
+
+ /**
+ * Helper method to search expansion
+ */
+ private findInExpansion(
+ contains: any[],
+ system?: string,
+ code?: string,
+ display?: string
+ ): boolean {
+ for (const item of contains) {
+ if (system && item.system && item.system !== system) {
+ continue;
+ }
+
+ if (item.code === code) {
+ if (!display || item.display === display) {
+ return true;
+ }
+ }
+
+ // Check nested contains
+ if (item.contains) {
+ if (this.findInExpansion(item.contains, system, code, display)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Expand a ValueSet (basic implementation)
+ */
+ expand(valueSetRef: string, count?: number, offset?: number): ValueSet | null {
+ const valueSet = this.getValueSet(valueSetRef);
+ if (!valueSet) {
+ return null;
+ }
+
+ // If already expanded, return as-is
+ if (valueSet.expansion) {
+ return valueSet;
+ }
+
+ // Basic expansion - would need code system lookup for full implementation
+ const expandedValueSet = { ...valueSet };
+ expandedValueSet.expansion = {
+ timestamp: new Date().toISOString(),
+ total: 0,
+ contains: []
+ };
+
+ if (valueSet.compose?.include) {
+ const allConcepts: any[] = [];
+ for (const include of valueSet.compose.include) {
+ if (include.concept) {
+ for (const concept of include.concept) {
+ allConcepts.push({
+ system: include.system,
+ code: concept.code,
+ display: concept.display
+ });
+ }
+ }
+ }
+
+ expandedValueSet.expansion.total = allConcepts.length;
+
+ if (offset) {
+ allConcepts.splice(0, offset);
+ }
+ if (count) {
+ allConcepts.splice(count);
+ }
+
+ expandedValueSet.expansion.contains = allConcepts;
+ }
+
+ return expandedValueSet;
+ }
+
+ /**
+ * Clear all ValueSets
+ */
+ clear(): void {
+ this.valueSets.clear();
+ }
+
+ /**
+ * Get count of registered ValueSets
+ */
+ getCount(): number {
+ return this.getAllValueSets().length;
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/api.test.ts b/packages/fmlrunner/tests/api.test.ts
new file mode 100644
index 0000000..5121e93
--- /dev/null
+++ b/packages/fmlrunner/tests/api.test.ts
@@ -0,0 +1,465 @@
+import request from 'supertest';
+import { FmlRunnerApi } from '../src/api/server';
+import { FmlRunner } from '../src';
+import * as path from 'path';
+
+describe('FmlRunnerApi', () => {
+ let api: FmlRunnerApi;
+ let app: any;
+ const testDataDir = path.join(__dirname, 'test-data');
+
+ beforeEach(() => {
+ const fmlRunner = new FmlRunner({ baseUrl: testDataDir });
+ api = new FmlRunnerApi(fmlRunner);
+ app = api.getApp();
+ });
+
+ describe('POST /api/v1/compile', () => {
+ it('should compile valid FML content', async () => {
+ const fmlContent = `
+ map "http://example.org/StructureMap/test" = "TestMap"
+ source -> target
+ `;
+
+ const response = await request(app)
+ .post('/api/v1/compile')
+ .send({ fmlContent })
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('StructureMap');
+ expect(response.body.name).toBe('TestMap');
+ });
+
+ it('should return 400 for missing fmlContent', async () => {
+ const response = await request(app)
+ .post('/api/v1/compile')
+ .send({})
+ .expect(400);
+
+ expect(response.body.error).toBe('fmlContent is required');
+ });
+
+ it('should return 400 for empty fmlContent', async () => {
+ const response = await request(app)
+ .post('/api/v1/compile')
+ .send({ fmlContent: '' })
+ .expect(400);
+
+ expect(response.body.error).toBe('fmlContent is required');
+ });
+ });
+
+ describe('POST /api/v1/execute', () => {
+ it('should execute StructureMap transformation', async () => {
+ const requestBody = {
+ structureMapReference: 'test-structure-map.json',
+ inputContent: { name: 'John Doe' }
+ };
+
+ const response = await request(app)
+ .post('/api/v1/execute')
+ .send(requestBody)
+ .expect(200);
+
+ expect(response.body.result).toEqual({ fullName: 'John Doe' });
+ });
+
+ it('should return 400 for missing parameters', async () => {
+ const response = await request(app)
+ .post('/api/v1/execute')
+ .send({ structureMapReference: 'test.json' })
+ .expect(400);
+
+ expect(response.body.error).toContain('structureMapReference and inputContent are required');
+ });
+
+ it('should return 400 for non-existent StructureMap', async () => {
+ const requestBody = {
+ structureMapReference: 'non-existent.json',
+ inputContent: { test: 'data' }
+ };
+
+ const response = await request(app)
+ .post('/api/v1/execute')
+ .send(requestBody)
+ .expect(400);
+
+ expect(response.body.error).toBe('StructureMap execution failed');
+ });
+ });
+
+ describe('GET /api/v1/structuremap/:reference', () => {
+ it('should retrieve existing StructureMap', async () => {
+ const response = await request(app)
+ .get('/api/v1/structuremap/test-structure-map.json')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('StructureMap');
+ expect(response.body.name).toBe('TestMap');
+ });
+
+ it('should return 404 for non-existent StructureMap', async () => {
+ const response = await request(app)
+ .get('/api/v1/structuremap/non-existent.json')
+ .expect(404);
+
+ expect(response.body.error).toBe('StructureMap not found');
+ });
+ });
+
+ describe('FHIR-compliant StructureMap endpoints', () => {
+ describe('GET /api/v1/StructureMap', () => {
+ it('should return empty bundle for search', async () => {
+ const response = await request(app)
+ .get('/api/v1/StructureMap')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Bundle');
+ expect(response.body.type).toBe('searchset');
+ expect(response.body.total).toBe(0);
+ });
+
+ it('should accept FHIR search parameters', async () => {
+ const response = await request(app)
+ .get('/api/v1/StructureMap?name=test&status=active&_count=10')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Bundle');
+ });
+ });
+
+ describe('GET /api/v1/StructureMap/:id', () => {
+ it('should retrieve StructureMap by ID', async () => {
+ const response = await request(app)
+ .get('/api/v1/StructureMap/test-structure-map.json')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('StructureMap');
+ expect(response.body.name).toBe('TestMap');
+ });
+
+ it('should return FHIR OperationOutcome for not found', async () => {
+ const response = await request(app)
+ .get('/api/v1/StructureMap/non-existent')
+ .expect(404);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].severity).toBe('error');
+ expect(response.body.issue[0].code).toBe('not-found');
+ });
+ });
+
+ describe('POST /api/v1/StructureMap', () => {
+ it('should create new StructureMap', async () => {
+ const structureMap = {
+ resourceType: 'StructureMap',
+ name: 'NewMap',
+ status: 'draft',
+ group: [{
+ name: 'main',
+ input: [{ name: 'source', mode: 'source' }],
+ rule: []
+ }]
+ };
+
+ const response = await request(app)
+ .post('/api/v1/StructureMap')
+ .send(structureMap)
+ .expect(201);
+
+ expect(response.body.resourceType).toBe('StructureMap');
+ expect(response.body.name).toBe('NewMap');
+ expect(response.body.id).toBeDefined();
+ });
+
+ it('should return FHIR OperationOutcome for invalid resource', async () => {
+ const response = await request(app)
+ .post('/api/v1/StructureMap')
+ .send({ resourceType: 'Patient' })
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].code).toBe('invalid');
+ });
+ });
+
+ describe('PUT /api/v1/StructureMap/:id', () => {
+ it('should update existing StructureMap', async () => {
+ const structureMap = {
+ resourceType: 'StructureMap',
+ name: 'UpdatedMap',
+ status: 'active',
+ group: [{
+ name: 'main',
+ input: [{ name: 'source', mode: 'source' }],
+ rule: []
+ }]
+ };
+
+ const response = await request(app)
+ .put('/api/v1/StructureMap/test-id')
+ .send(structureMap)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('StructureMap');
+ expect(response.body.id).toBe('test-id');
+ });
+ });
+
+ describe('DELETE /api/v1/StructureMap/:id', () => {
+ it('should delete StructureMap', async () => {
+ await request(app)
+ .delete('/api/v1/StructureMap/test-id')
+ .expect(204);
+ });
+ });
+ });
+
+ describe('POST /api/v1/StructureMap/\\$transform', () => {
+ it('should transform using FHIR Parameters', async () => {
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ {
+ name: 'source',
+ resource: { name: 'Jane Doe' }
+ },
+ {
+ name: 'map',
+ valueString: 'test-structure-map.json'
+ }
+ ]
+ };
+
+ const response = await request(app)
+ .post('/api/v1/StructureMap/$transform')
+ .send(parameters)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Parameters');
+ expect(response.body.parameter[0].name).toBe('result');
+ expect(response.body.parameter[0].resource.fullName).toBe('Jane Doe');
+ });
+
+ it('should return OperationOutcome for invalid Parameters', async () => {
+ const response = await request(app)
+ .post('/api/v1/StructureMap/$transform')
+ .send({ resourceType: 'Bundle' })
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].code).toBe('invalid');
+ });
+
+ it('should return OperationOutcome for missing parameters', async () => {
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ {
+ name: 'source',
+ resource: { name: 'Test' }
+ }
+ ]
+ };
+
+ const response = await request(app)
+ .post('/api/v1/StructureMap/$transform')
+ .send(parameters)
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].diagnostics).toContain('source" and "map" parameters');
+ });
+
+ it('should return OperationOutcome for transformation failure', async () => {
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ {
+ name: 'source',
+ resource: { name: 'Test' }
+ },
+ {
+ name: 'map',
+ valueString: 'non-existent.json'
+ }
+ ]
+ };
+
+ const response = await request(app)
+ .post('/api/v1/StructureMap/$transform')
+ .send(parameters)
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].code).toBe('processing');
+ });
+ });
+
+ describe('StructureDefinition endpoints', () => {
+ describe('GET /api/v1/StructureDefinition', () => {
+ it('should return empty bundle initially', async () => {
+ const response = await request(app)
+ .get('/api/v1/StructureDefinition')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Bundle');
+ expect(response.body.type).toBe('searchset');
+ expect(response.body.total).toBe(0);
+ });
+ });
+
+ describe('POST /api/v1/StructureDefinition', () => {
+ it('should create new StructureDefinition', async () => {
+ const structureDefinition = {
+ resourceType: 'StructureDefinition',
+ name: 'TestProfile',
+ status: 'draft',
+ kind: 'logical',
+ type: 'TestResource',
+ snapshot: {
+ element: [
+ {
+ path: 'TestResource',
+ min: 1,
+ max: '1'
+ }
+ ]
+ }
+ };
+
+ const response = await request(app)
+ .post('/api/v1/StructureDefinition')
+ .send(structureDefinition)
+ .expect(201);
+
+ expect(response.body.resourceType).toBe('StructureDefinition');
+ expect(response.body.name).toBe('TestProfile');
+ expect(response.body.id).toBeDefined();
+ });
+ });
+
+ describe('GET /api/v1/StructureDefinition/:id', () => {
+ it('should return 404 for non-existent StructureDefinition', async () => {
+ const response = await request(app)
+ .get('/api/v1/StructureDefinition/non-existent')
+ .expect(404);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ });
+ });
+ });
+
+ describe('Validation endpoints', () => {
+ beforeEach(async () => {
+ // Register a StructureDefinition for testing
+ const structureDefinition = {
+ resourceType: 'StructureDefinition',
+ url: 'http://example.org/StructureDefinition/TestPatient',
+ name: 'TestPatient',
+ status: 'active',
+ kind: 'resource',
+ type: 'Patient',
+ snapshot: {
+ element: [
+ {
+ path: 'Patient',
+ min: 1,
+ max: '1'
+ },
+ {
+ path: 'Patient.name',
+ min: 1,
+ max: '*',
+ type: [{ code: 'string' }]
+ }
+ ]
+ }
+ };
+
+ await request(app)
+ .post('/api/v1/StructureDefinition')
+ .send(structureDefinition);
+ });
+
+ describe('POST /api/v1/validate', () => {
+ it('should validate valid resource', async () => {
+ const requestBody = {
+ resource: {
+ resourceType: 'Patient',
+ name: 'John Doe'
+ },
+ profile: 'http://example.org/StructureDefinition/TestPatient'
+ };
+
+ const response = await request(app)
+ .post('/api/v1/validate')
+ .send(requestBody)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue).toBeDefined();
+ });
+
+ it('should return validation errors for invalid resource', async () => {
+ const requestBody = {
+ resource: {
+ resourceType: 'Patient'
+ // Missing required name field
+ },
+ profile: 'http://example.org/StructureDefinition/TestPatient'
+ };
+
+ const response = await request(app)
+ .post('/api/v1/validate')
+ .send(requestBody)
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue.length).toBeGreaterThan(0);
+ expect(response.body.issue[0].severity).toBe('error');
+ });
+
+ it('should return 400 for missing parameters', async () => {
+ const response = await request(app)
+ .post('/api/v1/validate')
+ .send({ resource: {} })
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].diagnostics).toContain('resource and profile are required');
+ });
+ });
+
+ describe('POST /api/v1/execute-with-validation', () => {
+ it('should execute with validation (basic test)', async () => {
+ const requestBody = {
+ structureMapReference: 'test-structure-map.json',
+ inputContent: { name: 'John Doe' },
+ options: {
+ strictMode: false
+ }
+ };
+
+ const response = await request(app)
+ .post('/api/v1/execute-with-validation')
+ .send(requestBody)
+ .expect(200);
+
+ expect(response.body.result).toBeDefined();
+ });
+ });
+ });
+
+ describe('GET /api/v1/health', () => {
+ it('should return health status', async () => {
+ const response = await request(app)
+ .get('/api/v1/health')
+ .expect(200);
+
+ expect(response.body.status).toBe('healthy');
+ expect(response.body.version).toBe('0.1.0');
+ expect(response.body.timestamp).toBeDefined();
+ });
+ });
+});
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/enhanced-api.test.ts b/packages/fmlrunner/tests/enhanced-api.test.ts
new file mode 100644
index 0000000..8fcd6cf
--- /dev/null
+++ b/packages/fmlrunner/tests/enhanced-api.test.ts
@@ -0,0 +1,454 @@
+import request from 'supertest';
+import { FmlRunnerApi } from '../src/api/server';
+import { FmlRunner } from '../src/index';
+
+describe('Enhanced FHIR Resource API Tests', () => {
+ let app: any;
+ let fmlRunner: FmlRunner;
+
+ beforeEach(() => {
+ fmlRunner = new FmlRunner();
+ const api = new FmlRunnerApi(fmlRunner);
+ app = api.getApp();
+ });
+
+ describe('Bundle Processing', () => {
+ describe('POST /api/v1/Bundle', () => {
+ it('should process a bundle with multiple resource types', async () => {
+ const bundle = {
+ resourceType: 'Bundle',
+ type: 'collection',
+ entry: [
+ {
+ resource: {
+ resourceType: 'ConceptMap',
+ id: 'test-cm',
+ url: 'http://example.org/ConceptMap/test',
+ status: 'active',
+ sourceUri: 'http://example.org/vs1',
+ targetUri: 'http://example.org/vs2',
+ group: [{
+ source: 'http://example.org/cs1',
+ target: 'http://example.org/cs2',
+ element: [{
+ code: 'A',
+ target: [{
+ code: 'B',
+ equivalence: 'equivalent'
+ }]
+ }]
+ }]
+ }
+ },
+ {
+ resource: {
+ resourceType: 'ValueSet',
+ id: 'test-vs',
+ url: 'http://example.org/ValueSet/test',
+ status: 'active',
+ compose: {
+ include: [{
+ system: 'http://example.org/cs1',
+ concept: [
+ { code: 'A', display: 'Alpha' },
+ { code: 'B', display: 'Beta' }
+ ]
+ }]
+ }
+ }
+ },
+ {
+ resource: {
+ resourceType: 'CodeSystem',
+ id: 'test-cs',
+ url: 'http://example.org/CodeSystem/test',
+ status: 'active',
+ content: 'complete',
+ concept: [
+ { code: 'A', display: 'Alpha' },
+ { code: 'B', display: 'Beta' }
+ ]
+ }
+ }
+ ]
+ };
+
+ const response = await request(app)
+ .post('/api/v1/Bundle')
+ .send(bundle)
+ .expect(201);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].severity).toBe('information');
+ expect(response.body.issue[0].diagnostics).toContain('1 ConceptMaps');
+ expect(response.body.issue[0].diagnostics).toContain('1 ValueSets');
+ expect(response.body.issue[0].diagnostics).toContain('1 CodeSystems');
+ });
+
+ it('should return error for invalid bundle', async () => {
+ const response = await request(app)
+ .post('/api/v1/Bundle')
+ .send({ invalid: 'data' })
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].code).toBe('invalid');
+ });
+ });
+
+ describe('GET /api/v1/Bundle/summary', () => {
+ it('should return summary of loaded resources', async () => {
+ const response = await request(app)
+ .get('/api/v1/Bundle/summary')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Bundle');
+ expect(response.body.type).toBe('collection');
+ });
+ });
+ });
+
+ describe('ConceptMap CRUD Operations', () => {
+ const testConceptMap = {
+ resourceType: 'ConceptMap',
+ name: 'TestConceptMap',
+ status: 'active',
+ sourceUri: 'http://example.org/vs1',
+ targetUri: 'http://example.org/vs2',
+ group: [{
+ source: 'http://example.org/cs1',
+ target: 'http://example.org/cs2',
+ element: [{
+ code: 'A',
+ target: [{
+ code: 'B',
+ equivalence: 'equivalent'
+ }]
+ }]
+ }]
+ };
+
+ describe('POST /api/v1/ConceptMap', () => {
+ it('should create a new ConceptMap', async () => {
+ const response = await request(app)
+ .post('/api/v1/ConceptMap')
+ .send(testConceptMap)
+ .expect(201);
+
+ expect(response.body.resourceType).toBe('ConceptMap');
+ expect(response.body.name).toBe('TestConceptMap');
+ expect(response.body.id).toBeDefined();
+ });
+
+ it('should reject invalid ConceptMap', async () => {
+ const response = await request(app)
+ .post('/api/v1/ConceptMap')
+ .send({ resourceType: 'Invalid' })
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ });
+ });
+
+ describe('GET /api/v1/ConceptMap', () => {
+ it('should search ConceptMaps', async () => {
+ const response = await request(app)
+ .get('/api/v1/ConceptMap')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Bundle');
+ expect(response.body.type).toBe('searchset');
+ });
+ });
+
+ describe('POST /api/v1/ConceptMap/$translate', () => {
+ it('should translate codes using loaded ConceptMaps', async () => {
+ // First, create a ConceptMap
+ await request(app)
+ .post('/api/v1/ConceptMap')
+ .send(testConceptMap)
+ .expect(201);
+
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'system', valueUri: 'http://example.org/cs1' },
+ { name: 'code', valueCode: 'A' },
+ { name: 'target', valueUri: 'http://example.org/cs2' }
+ ]
+ };
+
+ const response = await request(app)
+ .post('/api/v1/ConceptMap/$translate')
+ .send(parameters)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Parameters');
+ expect(response.body.parameter).toBeDefined();
+ });
+ });
+ });
+
+ describe('ValueSet CRUD Operations', () => {
+ const testValueSet = {
+ resourceType: 'ValueSet',
+ name: 'TestValueSet',
+ status: 'active',
+ compose: {
+ include: [{
+ system: 'http://example.org/cs1',
+ concept: [
+ { code: 'A', display: 'Alpha' },
+ { code: 'B', display: 'Beta' }
+ ]
+ }]
+ }
+ };
+
+ describe('POST /api/v1/ValueSet', () => {
+ it('should create a new ValueSet', async () => {
+ const response = await request(app)
+ .post('/api/v1/ValueSet')
+ .send(testValueSet)
+ .expect(201);
+
+ expect(response.body.resourceType).toBe('ValueSet');
+ expect(response.body.name).toBe('TestValueSet');
+ expect(response.body.id).toBeDefined();
+ });
+ });
+
+ describe('GET /api/v1/ValueSet', () => {
+ it('should search ValueSets', async () => {
+ const response = await request(app)
+ .get('/api/v1/ValueSet')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Bundle');
+ expect(response.body.type).toBe('searchset');
+ });
+ });
+
+ describe('POST /api/v1/ValueSet/$expand', () => {
+ it('should expand ValueSet', async () => {
+ // First, create a ValueSet
+ const createResponse = await request(app)
+ .post('/api/v1/ValueSet')
+ .send(testValueSet)
+ .expect(201);
+
+ const valueSetId = createResponse.body.id;
+
+ const response = await request(app)
+ .post(`/api/v1/ValueSet/${valueSetId}/$expand`)
+ .send({ resourceType: 'Parameters', parameter: [] })
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('ValueSet');
+ expect(response.body.expansion).toBeDefined();
+ });
+ });
+
+ describe('POST /api/v1/ValueSet/$validate-code', () => {
+ it('should validate code in ValueSet', async () => {
+ // First, create a ValueSet
+ const createResponse = await request(app)
+ .post('/api/v1/ValueSet')
+ .send(testValueSet)
+ .expect(201);
+
+ const valueSetId = createResponse.body.id;
+
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'system', valueUri: 'http://example.org/cs1' },
+ { name: 'code', valueCode: 'A' }
+ ]
+ };
+
+ const response = await request(app)
+ .post(`/api/v1/ValueSet/${valueSetId}/$validate-code`)
+ .send(parameters)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Parameters');
+ expect(response.body.parameter).toBeDefined();
+ expect(response.body.parameter.find((p: any) => p.name === 'result')?.valueBoolean).toBe(true);
+ });
+ });
+ });
+
+ describe('CodeSystem CRUD Operations', () => {
+ const testCodeSystem = {
+ resourceType: 'CodeSystem',
+ name: 'TestCodeSystem',
+ status: 'active',
+ content: 'complete',
+ concept: [
+ { code: 'A', display: 'Alpha', definition: 'First letter' },
+ { code: 'B', display: 'Beta', definition: 'Second letter' }
+ ]
+ };
+
+ describe('POST /api/v1/CodeSystem', () => {
+ it('should create a new CodeSystem', async () => {
+ const response = await request(app)
+ .post('/api/v1/CodeSystem')
+ .send(testCodeSystem)
+ .expect(201);
+
+ expect(response.body.resourceType).toBe('CodeSystem');
+ expect(response.body.name).toBe('TestCodeSystem');
+ expect(response.body.id).toBeDefined();
+ });
+ });
+
+ describe('GET /api/v1/CodeSystem', () => {
+ it('should search CodeSystems', async () => {
+ const response = await request(app)
+ .get('/api/v1/CodeSystem')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Bundle');
+ expect(response.body.type).toBe('searchset');
+ });
+ });
+
+ describe('POST /api/v1/CodeSystem/$lookup', () => {
+ it('should lookup concept in CodeSystem', async () => {
+ // First, create a CodeSystem
+ const createResponse = await request(app)
+ .post('/api/v1/CodeSystem')
+ .send(testCodeSystem)
+ .expect(201);
+
+ const codeSystemId = createResponse.body.id;
+
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'code', valueCode: 'A' }
+ ]
+ };
+
+ const response = await request(app)
+ .post(`/api/v1/CodeSystem/${codeSystemId}/$lookup`)
+ .send(parameters)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Parameters');
+ expect(response.body.parameter).toBeDefined();
+ expect(response.body.parameter.find((p: any) => p.name === 'display')?.valueString).toBe('Alpha');
+ });
+ });
+
+ describe('POST /api/v1/CodeSystem/$validate-code', () => {
+ it('should validate code in CodeSystem', async () => {
+ // First, create a CodeSystem
+ const createResponse = await request(app)
+ .post('/api/v1/CodeSystem')
+ .send(testCodeSystem)
+ .expect(201);
+
+ const codeSystemId = createResponse.body.id;
+
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'code', valueCode: 'A' }
+ ]
+ };
+
+ const response = await request(app)
+ .post(`/api/v1/CodeSystem/${codeSystemId}/$validate-code`)
+ .send(parameters)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Parameters');
+ expect(response.body.parameter).toBeDefined();
+ expect(response.body.parameter.find((p: any) => p.name === 'result')?.valueBoolean).toBe(true);
+ });
+ });
+
+ describe('POST /api/v1/CodeSystem/$subsumes', () => {
+ it('should test subsumption between codes', async () => {
+ // First, create a CodeSystem
+ const createResponse = await request(app)
+ .post('/api/v1/CodeSystem')
+ .send(testCodeSystem)
+ .expect(201);
+
+ const codeSystemId = createResponse.body.id;
+
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'codeA', valueCode: 'A' },
+ { name: 'codeB', valueCode: 'B' }
+ ]
+ };
+
+ const response = await request(app)
+ .post(`/api/v1/CodeSystem/${codeSystemId}/$subsumes`)
+ .send(parameters)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Parameters');
+ expect(response.body.parameter).toBeDefined();
+ expect(response.body.parameter.find((p: any) => p.name === 'outcome')?.valueCode).toBeDefined();
+ });
+ });
+ });
+
+ describe('Library API Integration', () => {
+ it('should allow direct library access to all resource types', () => {
+ // Test ConceptMap methods
+ const conceptMap = {
+ resourceType: 'ConceptMap' as const,
+ id: 'test-cm',
+ status: 'active' as const
+ };
+ fmlRunner.registerConceptMap(conceptMap);
+ expect(fmlRunner.getConceptMap('test-cm')).toEqual(conceptMap);
+ expect(fmlRunner.getAllConceptMaps()).toContain(conceptMap);
+
+ // Test ValueSet methods
+ const valueSet = {
+ resourceType: 'ValueSet' as const,
+ id: 'test-vs',
+ status: 'active' as const
+ };
+ fmlRunner.registerValueSet(valueSet);
+ expect(fmlRunner.getValueSet('test-vs')).toEqual(valueSet);
+ expect(fmlRunner.getAllValueSets()).toContain(valueSet);
+
+ // Test CodeSystem methods
+ const codeSystem = {
+ resourceType: 'CodeSystem' as const,
+ id: 'test-cs',
+ status: 'active' as const,
+ content: 'complete' as const
+ };
+ fmlRunner.registerCodeSystem(codeSystem);
+ expect(fmlRunner.getCodeSystem('test-cs')).toEqual(codeSystem);
+ expect(fmlRunner.getAllCodeSystems()).toContain(codeSystem);
+
+ // Test Bundle processing
+ const bundle = {
+ resourceType: 'Bundle' as const,
+ type: 'collection' as const,
+ entry: [
+ { resource: conceptMap },
+ { resource: valueSet },
+ { resource: codeSystem }
+ ]
+ };
+ const result = fmlRunner.processBundle(bundle);
+ expect(result.success).toBe(true);
+ expect(result.processed.conceptMaps).toBe(1);
+ expect(result.processed.valueSets).toBe(1);
+ expect(result.processed.codeSystems).toBe(1);
+ });
+ });
+});
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/enhanced-tokenizer.test.ts b/packages/fmlrunner/tests/enhanced-tokenizer.test.ts
new file mode 100644
index 0000000..774f98c
--- /dev/null
+++ b/packages/fmlrunner/tests/enhanced-tokenizer.test.ts
@@ -0,0 +1,151 @@
+import { FmlCompiler } from '../src/lib/fml-compiler';
+
+describe('Enhanced FML Tokenizer', () => {
+ let compiler: FmlCompiler;
+
+ beforeEach(() => {
+ compiler = new FmlCompiler();
+ });
+
+ test('should handle multi-line comments', () => {
+ const fmlWithMultiLineComment = `
+ /* This is a multi-line comment
+ spanning multiple lines */
+ map "http://example.org/test" = "TestMap"
+
+ group main(source : Patient) {
+ name : source.name -> target.name;
+ }
+ `;
+
+ const result = compiler.compile(fmlWithMultiLineComment);
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.url).toBe('http://example.org/test');
+ expect(result.structureMap?.name).toBe('TestMap');
+ });
+
+ test('should handle documentation comments', () => {
+ const fmlWithDocComment = `
+ /// This is a documentation comment
+ map "http://example.org/test2" = "TestMap2"
+
+ group main(source : Patient) {
+ name : source.name -> target.name;
+ }
+ `;
+
+ const result = compiler.compile(fmlWithDocComment);
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.url).toBe('http://example.org/test2');
+ expect(result.structureMap?.name).toBe('TestMap2');
+ });
+
+ test('should handle prefix declarations', () => {
+ const fmlWithPrefix = `
+ map "http://example.org/test3" = "TestMap3"
+ prefix system = "http://terminology.hl7.org/CodeSystem/v3-ActCode"
+
+ group main(source : Patient) {
+ name : source.name -> target.name;
+ }
+ `;
+
+ const result = compiler.compile(fmlWithPrefix);
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.url).toBe('http://example.org/test3');
+ expect(result.structureMap?.name).toBe('TestMap3');
+ });
+
+ test('should handle conceptmap declarations', () => {
+ const fmlWithConceptMap = `
+ map "http://example.org/test4" = "TestMap4"
+ conceptmap "http://example.org/conceptmap" {
+ target "http://terminology.hl7.org/CodeSystem/observation-category"
+ element[0].target.code = "survey"
+ }
+
+ group main(source : Patient) {
+ name : source.name -> target.name;
+ }
+ `;
+
+ const result = compiler.compile(fmlWithConceptMap);
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.url).toBe('http://example.org/test4');
+ expect(result.structureMap?.name).toBe('TestMap4');
+ });
+
+ test('should handle all enhanced preamble features combined', () => {
+ const fmlWithAllFeatures = `
+ /* Multi-line comment explaining the mapping */
+ /// Documentation for this map
+ map "http://example.org/comprehensive" = "ComprehensiveMap"
+
+ prefix loinc = "http://loinc.org"
+ uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as source
+ imports "http://example.org/other-map"
+
+ conceptmap "http://example.org/codes" {
+ target "http://terminology.hl7.org/CodeSystem/observation-category"
+ }
+
+ group main(source Patient : Patient, target : Patient) {
+ // Single line comment
+ name : source.name -> target.name;
+ }
+ `;
+
+ const result = compiler.compile(fmlWithAllFeatures);
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.url).toBe('http://example.org/comprehensive');
+ expect(result.structureMap?.name).toBe('ComprehensiveMap');
+ expect(result.structureMap?.group).toHaveLength(1);
+ expect(result.structureMap?.group[0].name).toBe('main');
+ });
+
+ test('should handle nested braces in conceptmap declarations', () => {
+ const fmlWithNestedBraces = `
+ map "http://example.org/nested" = "NestedMap"
+ conceptmap "http://example.org/complex" {
+ target "http://terminology.hl7.org/CodeSystem/observation-category"
+ group MyGroup {
+ element[0] {
+ target.code = "survey"
+ target.display = "Survey"
+ }
+ }
+ }
+
+ group main(source : Patient) {
+ name : source.name -> target.name;
+ }
+ `;
+
+ const result = compiler.compile(fmlWithNestedBraces);
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.url).toBe('http://example.org/nested');
+ expect(result.structureMap?.name).toBe('NestedMap');
+ });
+
+ test('should handle mixed comment types', () => {
+ const fmlWithMixedComments = `
+ /* Multi-line comment at the start */
+ /// Documentation comment
+ map "http://example.org/mixed" = "MixedComments"
+
+ // Single line comment
+ /* Another multi-line
+ comment block */
+
+ group main(source : Patient) {
+ /// Documentation for this rule
+ name : source.name -> target.name; // Inline comment
+ }
+ `;
+
+ const result = compiler.compile(fmlWithMixedComments);
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.url).toBe('http://example.org/mixed');
+ expect(result.structureMap?.name).toBe('MixedComments');
+ });
+});
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/fhir-mapping-language.test.ts b/packages/fmlrunner/tests/fhir-mapping-language.test.ts
new file mode 100644
index 0000000..c96deec
--- /dev/null
+++ b/packages/fmlrunner/tests/fhir-mapping-language.test.ts
@@ -0,0 +1,340 @@
+import { FmlRunner } from '../src/index';
+import { FmlCompiler } from '../src/lib/fml-compiler';
+import { StructureMapExecutor } from '../src/lib/structure-map-executor';
+import { StructureMapRetriever } from '../src/lib/structure-map-retriever';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+describe('FHIR Mapping Language Tests (Matchbox-style)', () => {
+ let fmlRunner: FmlRunner;
+ let compiler: FmlCompiler;
+ let executor: StructureMapExecutor;
+ let retriever: StructureMapRetriever;
+
+ beforeAll(() => {
+ fmlRunner = new FmlRunner({ baseUrl: './tests/mapping-language' });
+ compiler = new FmlCompiler();
+ executor = new StructureMapExecutor();
+ retriever = new StructureMapRetriever();
+ retriever.setBaseDirectory('./tests/mapping-language');
+ });
+
+ // Helper function to load file content
+ function getFileAsString(relativePath: string): string {
+ const fullPath = join(__dirname, 'mapping-language', relativePath);
+ return readFileSync(fullPath, 'utf-8');
+ }
+
+ describe('Basic FML Compilation Tests', () => {
+ test('testQr2PatientCompilation', () => {
+ // Load and compile the mapping
+ const mapContent = getFileAsString('/maps/qr2patgender.map');
+ const compilationResult = compiler.compile(mapContent);
+
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.resourceType).toBe('StructureMap');
+ expect(compilationResult.structureMap!.url).toBe('http://ahdis.ch/matchbox/fml/qr2patgender');
+ expect(compilationResult.structureMap!.name).toBe('qr2patgender');
+ expect(compilationResult.structureMap!.group).toBeTruthy();
+ expect(compilationResult.structureMap!.group.length).toBeGreaterThan(0);
+ });
+
+ test('testMemberOfCompilation', () => {
+ const mapContent = getFileAsString('/maps/memberof.map');
+ const compilationResult = compiler.compile(mapContent);
+
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.url).toBe('http://ahdis.ch/matchbox/fml/memberof');
+ expect(compilationResult.structureMap!.name).toBe('memberof');
+ });
+
+ test('testNarrativeCompilation', () => {
+ const mapContent = getFileAsString('/maps/narrative.map');
+ const compilationResult = compiler.compile(mapContent);
+
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.url).toBe('http://ahdis.ch/matchbox/fml/narrative');
+ });
+
+ test('testStringToCodingCompilation', () => {
+ const mapContent = getFileAsString('/maps/stringtocoding.map');
+ const compilationResult = compiler.compile(mapContent);
+
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.url).toBe('http://ahdis.ch/matchbox/fml/stringtocoding');
+ });
+ });
+
+ describe('Basic Execution Tests', () => {
+ test('testBasicExecution', async () => {
+ // Load the mapping
+ const mapContent = getFileAsString('/maps/qr2patgender.map');
+ const compilationResult = compiler.compile(mapContent);
+ expect(compilationResult.success).toBe(true);
+
+ // Load the source data
+ const sourceData = getFileAsString('/data/qr.json');
+ const sourceObj = JSON.parse(sourceData);
+
+ // Execute transformation - with current basic implementation
+ const result = await executor.execute(compilationResult.structureMap!, sourceObj);
+ expect(result.success).toBe(true);
+ expect(result.result).toBeTruthy();
+ // Note: Current implementation returns basic structure, not full transformation
+ });
+
+ test('testExecutionWithValidation', async () => {
+ const mapContent = getFileAsString('/maps/qr2patgender.map');
+ const compilationResult = compiler.compile(mapContent);
+ expect(compilationResult.success).toBe(true);
+
+ const sourceData = getFileAsString('/data/qr.json');
+ const sourceObj = JSON.parse(sourceData);
+
+ // Execute with validation options
+ const result = await executor.execute(compilationResult.structureMap!, sourceObj, {
+ strictMode: false,
+ validateInput: false,
+ validateOutput: false
+ });
+
+ expect(result.success).toBe(true);
+ expect(result.validation).toBeTruthy();
+ });
+ });
+
+ describe('Integration with FmlRunner', () => {
+ test('compile through FmlRunner', () => {
+ const mapContent = getFileAsString('/maps/qr2patgender.map');
+ const compilationResult = fmlRunner.compileFml(mapContent);
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ });
+
+ test('test retriever loading compiled maps', async () => {
+ // Try to load compiled StructureMap JSON file
+ const structureMap = await retriever.getStructureMap('compiled/qr2patgender.json');
+ expect(structureMap).toBeTruthy();
+ if (structureMap) {
+ expect(structureMap.url).toBe('http://ahdis.ch/matchbox/fml/qr2patgender');
+ expect(structureMap.resourceType).toBe('StructureMap');
+ }
+ });
+ });
+
+ describe('Error Handling Tests', () => {
+ test('testParseFailWithError', () => {
+ const invalidMapContent = `
+ invalid syntax here
+ map without proper structure
+ missing quotes and format
+ `;
+
+ const compilationResult = compiler.compile(invalidMapContent);
+ // Current implementation is basic, but should at least not crash
+ expect(compilationResult).toBeTruthy();
+ expect(compilationResult.success).toBeDefined();
+ });
+
+ test('testExecutionWithEmptyInput', async () => {
+ const mapContent = getFileAsString('/maps/qr2patgender.map');
+ const compilationResult = compiler.compile(mapContent);
+ expect(compilationResult.success).toBe(true);
+
+ // Try to execute with empty source
+ const result = await executor.execute(compilationResult.structureMap!, {});
+ expect(result).toBeTruthy();
+ expect(result.success).toBeDefined();
+ });
+
+ test('testExecutionWithNullStructureMap', async () => {
+ const result = await executor.execute(null as any, {});
+ expect(result.success).toBe(false);
+ expect(result.errors).toBeTruthy();
+ expect(result.errors![0]).toContain('StructureMap is required');
+ });
+ });
+
+ describe('Advanced Compilation Features', () => {
+ test('Date Manipulation Compilation', () => {
+ const dateMapContent = `
+ map "http://ahdis.ch/matchbox/fml/qr2patfordates" = "qr2patfordates"
+
+ uses "http://hl7.org/fhir/StructureDefinition/QuestionnaireResponse" alias QuestionnaireResponse as source
+ uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as target
+
+ group qr2pat(source src : QuestionnaireResponse, target tgt : Patient) {
+ src -> tgt.birthDate = '2023-10-26' "birthDate";
+ src -> tgt.deceased = '2023-09-20T13:19:13.502Z' "deceased";
+ }
+ `;
+
+ const compilationResult = compiler.compile(dateMapContent);
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.url).toBe('http://ahdis.ch/matchbox/fml/qr2patfordates');
+ });
+
+ test('Bundle Mapping Compilation', () => {
+ const bundleMapContent = `
+ map "http://test.ch/DummyBundleToBundle" = "bundleTest"
+
+ uses "http://hl7.org/fhir/StructureDefinition/Bundle" alias Bundle as source
+ uses "http://hl7.org/fhir/StructureDefinition/Bundle" alias Bundle as target
+
+ group bundle2bundle(source src : Bundle, target tgt : Bundle) {
+ src.type -> tgt.type;
+ src.entry -> tgt.entry;
+ }
+ `;
+
+ const compilationResult = compiler.compile(bundleMapContent);
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.url).toBe('http://test.ch/DummyBundleToBundle');
+ expect(compilationResult.structureMap!.name).toBe('bundleTest');
+ });
+
+ test('Conditional Mapping Compilation', () => {
+ const conditionalMapContent = `
+ map "http://ahdis.ch/matchbox/fml/whereclause" = "whereclause"
+
+ uses "http://hl7.org/fhir/StructureDefinition/CapabilityStatement" alias CapabilityStatement as source
+ uses "http://hl7.org/fhir/StructureDefinition/CapabilityStatement" alias CapabilityStatement as target
+
+ group cap2cap(source src : CapabilityStatement, target tgt : CapabilityStatement) {
+ src.rest as rest -> tgt.rest = rest then {
+ rest.resource as resource -> tgt.rest.resource = resource then {
+ resource.interaction as interaction where type = 'read' -> tgt.rest.resource.interaction = interaction;
+ };
+ };
+ }
+ `;
+
+ const compilationResult = compiler.compile(conditionalMapContent);
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.url).toBe('http://ahdis.ch/matchbox/fml/whereclause');
+ });
+ });
+
+ describe('Performance and Data Handling Tests', () => {
+ test('Large FML Content Compilation', () => {
+ // Create a large FML content with many rules
+ let largeFmlContent = `
+ map "http://example.org/large-map" = "largeMap"
+
+ uses "http://hl7.org/fhir/StructureDefinition/Bundle" alias Bundle as source
+ uses "http://hl7.org/fhir/StructureDefinition/Bundle" alias Bundle as target
+
+ group bundle2bundle(source src : Bundle, target tgt : Bundle) {
+ src.type -> tgt.type;
+ `;
+
+ // Add many transformation rules
+ for (let i = 0; i < 100; i++) {
+ largeFmlContent += `\n src.entry${i} -> tgt.entry${i};`;
+ }
+ largeFmlContent += '\n }';
+
+ const startTime = Date.now();
+ const compilationResult = compiler.compile(largeFmlContent);
+ const endTime = Date.now();
+
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+
+ const compilationTime = endTime - startTime;
+ console.log(`Large FML compilation took ${compilationTime}ms for 100+ rules`);
+ expect(compilationTime).toBeLessThan(1000); // Should compile within 1 second
+ });
+
+ test('Memory usage with large StructureMap', async () => {
+ const mapContent = getFileAsString('/maps/qr2patgender.map');
+
+ // Compile multiple times to test memory usage
+ const startMemory = process.memoryUsage().heapUsed;
+
+ for (let i = 0; i < 100; i++) {
+ const compilationResult = compiler.compile(mapContent);
+ expect(compilationResult.success).toBe(true);
+ }
+
+ const endMemory = process.memoryUsage().heapUsed;
+ const memoryIncrease = endMemory - startMemory;
+
+ console.log(`Memory increase after 100 compilations: ${memoryIncrease / 1024 / 1024} MB`);
+ // Should not increase memory dramatically
+ expect(memoryIncrease).toBeLessThan(50 * 1024 * 1024); // Less than 50MB increase
+ });
+ });
+
+ describe('Tutorial-style Tests', () => {
+ test('Tutorial Step 1 - Basic mapping compilation', () => {
+ const tutorialContent = getFileAsString('/tutorial/step1/map/step1.map');
+ const compilationResult = compiler.compile(tutorialContent);
+
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.url).toBe('http://hl7.org/fhir/StructureMap/tutorial-step1');
+ expect(compilationResult.structureMap!.name).toBe('tutorial-step1');
+ });
+
+ test('Tutorial Step 1 - Basic execution', async () => {
+ const tutorialContent = getFileAsString('/tutorial/step1/map/step1.map');
+ const compilationResult = compiler.compile(tutorialContent);
+ expect(compilationResult.success).toBe(true);
+
+ const sourceData = getFileAsString('/tutorial/step1/source/source1.json');
+ const sourceObj = JSON.parse(sourceData);
+
+ const result = await executor.execute(compilationResult.structureMap!, sourceObj);
+ expect(result.success).toBe(true);
+ expect(result.result).toBeTruthy();
+ });
+ });
+
+ describe('Validation Service Integration', () => {
+ test('Get validation service', () => {
+ const validationService = executor.getValidationService();
+ expect(validationService).toBeTruthy();
+ });
+
+ test('Execute with validation service', async () => {
+ const mapContent = getFileAsString('/maps/qr2patgender.map');
+ const compilationResult = compiler.compile(mapContent);
+ expect(compilationResult.success).toBe(true);
+
+ const sourceData = getFileAsString('/data/qr.json');
+ const sourceObj = JSON.parse(sourceData);
+
+ // Register a basic StructureDefinition
+ const validationService = executor.getValidationService();
+ const basicStructureDefinition = {
+ resourceType: 'StructureDefinition' as const,
+ url: 'http://example.org/test',
+ name: 'TestStructure',
+ status: 'active' as const,
+ kind: 'logical' as const,
+ type: 'Test',
+ differential: {
+ element: [
+ {
+ path: 'Test',
+ id: 'Test'
+ }
+ ]
+ }
+ };
+
+ validationService.registerStructureDefinition(basicStructureDefinition);
+
+ const result = await executor.execute(compilationResult.structureMap!, sourceObj);
+ expect(result.success).toBe(true);
+ });
+ });
+});
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/fhirpath-integration.test.ts b/packages/fmlrunner/tests/fhirpath-integration.test.ts
new file mode 100644
index 0000000..3107c00
--- /dev/null
+++ b/packages/fmlrunner/tests/fhirpath-integration.test.ts
@@ -0,0 +1,108 @@
+import { StructureMapExecutor } from '../src/lib/structure-map-executor';
+import { StructureMap } from '../src/types';
+
+describe('FHIRPath Integration', () => {
+ let executor: StructureMapExecutor;
+
+ beforeEach(() => {
+ executor = new StructureMapExecutor();
+ });
+
+ test('should use proper FHIRPath evaluation for simple expressions', () => {
+ const structureMap: StructureMap = {
+ resourceType: 'StructureMap',
+ id: 'test-fhirpath',
+ name: 'TestFHIRPath',
+ url: 'http://example.com/StructureMap/test-fhirpath',
+ status: 'draft',
+ group: [{
+ name: 'main',
+ input: [{ name: 'source', mode: 'source' }],
+ rule: [{
+ name: 'test-evaluate',
+ source: [{ element: 'name', context: 'source' }],
+ target: [{
+ element: 'result',
+ transform: 'evaluate',
+ parameter: ['first().given.first()']
+ }]
+ }]
+ }]
+ };
+
+ const inputData = {
+ name: [{
+ given: ['John', 'Middle'],
+ family: 'Doe'
+ }]
+ };
+
+ const result = executor.execute(structureMap, inputData);
+
+ expect(result.success).toBe(true);
+ expect(result.result).toHaveProperty('result');
+ expect(result.result.result).toBe('John'); // Should extract first given name
+ });
+
+ test('should handle FHIRPath evaluation errors gracefully', () => {
+ const structureMap: StructureMap = {
+ resourceType: 'StructureMap',
+ id: 'test-fhirpath-error',
+ name: 'TestFHIRPathError',
+ url: 'http://example.com/StructureMap/test-fhirpath-error',
+ status: 'draft',
+ group: [{
+ name: 'main',
+ input: [{ name: 'source', mode: 'source' }],
+ rule: [{
+ name: 'test-evaluate-error',
+ source: [{ element: 'data', context: 'source' }],
+ target: [{
+ element: 'result',
+ transform: 'evaluate',
+ parameter: ['invalid FHIRPath syntax...']
+ }]
+ }]
+ }]
+ };
+
+ const inputData = { data: 'test' };
+
+ const result = executor.execute(structureMap, inputData);
+
+ expect(result.success).toBe(true);
+ expect(result.result).toHaveProperty('result');
+ expect(result.result.result).toBeUndefined(); // Should return undefined for failed evaluations
+ });
+
+ test('should work with boolean expressions', () => {
+ const structureMap: StructureMap = {
+ resourceType: 'StructureMap',
+ id: 'test-boolean',
+ name: 'TestBoolean',
+ url: 'http://example.com/StructureMap/test-boolean',
+ status: 'draft',
+ group: [{
+ name: 'main',
+ input: [{ name: 'source', mode: 'source' }],
+ rule: [{
+ name: 'test-boolean',
+ source: [{ element: 'active', context: 'source' }],
+ target: [{
+ element: 'isActive',
+ transform: 'evaluate',
+ parameter: ['true']
+ }]
+ }]
+ }]
+ };
+
+ const inputData = { active: true };
+
+ const result = executor.execute(structureMap, inputData);
+
+ expect(result.success).toBe(true);
+ expect(result.result).toHaveProperty('isActive');
+ expect(result.result.isActive).toBe(true);
+ });
+});
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/fml-compiler.test.ts b/packages/fmlrunner/tests/fml-compiler.test.ts
new file mode 100644
index 0000000..d1fa14f
--- /dev/null
+++ b/packages/fmlrunner/tests/fml-compiler.test.ts
@@ -0,0 +1,55 @@
+import { FmlCompiler } from '../src/lib/fml-compiler';
+
+describe('FmlCompiler', () => {
+ let compiler: FmlCompiler;
+
+ beforeEach(() => {
+ compiler = new FmlCompiler();
+ });
+
+ describe('compile', () => {
+ it('should reject empty FML content', () => {
+ const result = compiler.compile('');
+ expect(result.success).toBe(false);
+ expect(result.errors).toContain('FML content cannot be empty');
+ });
+
+ it('should reject whitespace-only FML content', () => {
+ const result = compiler.compile(' \n \t ');
+ expect(result.success).toBe(false);
+ expect(result.errors).toContain('FML content cannot be empty');
+ });
+
+ it('should compile basic FML to StructureMap', () => {
+ const fmlContent = `
+ map "http://example.org/StructureMap/test" = "TestMap"
+
+ source -> target
+ `;
+
+ const result = compiler.compile(fmlContent);
+ expect(result.success).toBe(true);
+ expect(result.structureMap).toBeDefined();
+ expect(result.structureMap?.resourceType).toBe('StructureMap');
+ expect(result.structureMap?.name).toBe('TestMap');
+ expect(result.structureMap?.url).toBe('http://example.org/StructureMap/test');
+ });
+
+ it('should handle compilation errors gracefully', () => {
+ // Test with malformed content that should trigger an error
+ const result = compiler.compile('invalid fml content');
+ expect(result.success).toBe(true); // Enhanced parser should handle this gracefully with fallback
+ expect(result.structureMap).toBeDefined();
+ expect(result.structureMap?.name).toBe('DefaultMap'); // Should use fallback
+ });
+
+ it('should create default structure when no map declaration found', () => {
+ const fmlContent = 'some -> mapping';
+ const result = compiler.compile(fmlContent);
+
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.name).toBe('DefaultMap');
+ expect(result.structureMap?.url).toContain('DefaultMap');
+ });
+ });
+});
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/fml-runner.test.ts b/packages/fmlrunner/tests/fml-runner.test.ts
new file mode 100644
index 0000000..7991567
--- /dev/null
+++ b/packages/fmlrunner/tests/fml-runner.test.ts
@@ -0,0 +1,73 @@
+import { FmlRunner } from '../src';
+import * as path from 'path';
+
+describe('FmlRunner', () => {
+ let runner: FmlRunner;
+ const testDataDir = path.join(__dirname, 'test-data');
+
+ beforeEach(() => {
+ runner = new FmlRunner({ baseUrl: testDataDir });
+ });
+
+ describe('compileFml', () => {
+ it('should compile valid FML content', () => {
+ const fmlContent = `
+ map "http://example.org/StructureMap/test" = "TestMap"
+ source -> target
+ `;
+
+ const result = runner.compileFml(fmlContent);
+ expect(result.success).toBe(true);
+ expect(result.structureMap).toBeDefined();
+ });
+
+ it('should reject empty FML content', () => {
+ const result = runner.compileFml('');
+ expect(result.success).toBe(false);
+ expect(result.errors).toBeDefined();
+ });
+ });
+
+ describe('executeStructureMap', () => {
+ it('should execute StructureMap from file', async () => {
+ const inputData = { name: 'John Doe' };
+ const result = await runner.executeStructureMap('test-structure-map.json', inputData);
+
+ expect(result.success).toBe(true);
+ expect(result.result).toEqual({ fullName: 'John Doe' });
+ });
+
+ it('should return error for non-existent StructureMap', async () => {
+ const result = await runner.executeStructureMap('non-existent.json', {});
+ expect(result.success).toBe(false);
+ expect(result.errors?.[0]).toContain('StructureMap not found');
+ });
+ });
+
+ describe('getStructureMap', () => {
+ it('should retrieve StructureMap from file', async () => {
+ const structureMap = await runner.getStructureMap('test-structure-map.json');
+ expect(structureMap).toBeDefined();
+ expect(structureMap?.resourceType).toBe('StructureMap');
+ expect(structureMap?.name).toBe('TestMap');
+ });
+
+ it('should return null for non-existent file', async () => {
+ const result = await runner.getStructureMap('non-existent.json');
+ expect(result).toBeNull();
+ });
+ });
+
+ describe('clearCache', () => {
+ it('should clear cache without errors', () => {
+ expect(() => runner.clearCache()).not.toThrow();
+ });
+ });
+
+ describe('setBaseDirectory', () => {
+ it('should update base directory', () => {
+ const newDir = '/new/path';
+ expect(() => runner.setBaseDirectory(newDir)).not.toThrow();
+ });
+ });
+});
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/mapping-language/compiled/qr2patgender.json b/packages/fmlrunner/tests/mapping-language/compiled/qr2patgender.json
new file mode 100644
index 0000000..72dc92b
--- /dev/null
+++ b/packages/fmlrunner/tests/mapping-language/compiled/qr2patgender.json
@@ -0,0 +1,46 @@
+{
+ "resourceType": "StructureMap",
+ "url": "http://ahdis.ch/matchbox/fml/qr2patgender",
+ "name": "qr2patgender",
+ "status": "draft",
+ "group": [
+ {
+ "name": "main",
+ "input": [
+ {
+ "name": "source",
+ "mode": "source"
+ },
+ {
+ "name": "target",
+ "mode": "target"
+ }
+ ],
+ "rule": [
+ {
+ "name": "rule1",
+ "source": [
+ {
+ "context": "source",
+ "element": "item",
+ "variable": "item",
+ "condition": "linkId = 'gender'"
+ }
+ ],
+ "target": [
+ {
+ "context": "target",
+ "element": "gender",
+ "transform": "copy",
+ "parameter": [
+ {
+ "valueString": "item.answer.valueString"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/mapping-language/data/capabilitystatement-example.json b/packages/fmlrunner/tests/mapping-language/data/capabilitystatement-example.json
new file mode 100644
index 0000000..5316a47
--- /dev/null
+++ b/packages/fmlrunner/tests/mapping-language/data/capabilitystatement-example.json
@@ -0,0 +1,23 @@
+{
+ "resourceType": "CapabilityStatement",
+ "id": "example",
+ "status": "active",
+ "date": "2023-01-01",
+ "rest": [
+ {
+ "mode": "server",
+ "resource": [
+ {
+ "type": "Patient",
+ "interaction": [
+ { "code": "read" },
+ { "code": "search-type" },
+ { "code": "create" },
+ { "code": "update" },
+ { "code": "delete" }
+ ]
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/mapping-language/data/pat.json b/packages/fmlrunner/tests/mapping-language/data/pat.json
new file mode 100644
index 0000000..10fb44e
--- /dev/null
+++ b/packages/fmlrunner/tests/mapping-language/data/pat.json
@@ -0,0 +1,11 @@
+{
+ "resourceType": "Patient",
+ "id": "pat-1",
+ "gender": "male",
+ "name": [
+ {
+ "family": "Doe",
+ "given": ["John"]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/mapping-language/data/qr.json b/packages/fmlrunner/tests/mapping-language/data/qr.json
new file mode 100644
index 0000000..59df4b4
--- /dev/null
+++ b/packages/fmlrunner/tests/mapping-language/data/qr.json
@@ -0,0 +1,15 @@
+{
+ "resourceType": "QuestionnaireResponse",
+ "id": "qr-1",
+ "status": "completed",
+ "item": [
+ {
+ "linkId": "gender",
+ "answer": [
+ {
+ "valueString": "female"
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/mapping-language/data/qrext.json b/packages/fmlrunner/tests/mapping-language/data/qrext.json
new file mode 100644
index 0000000..937bdba
--- /dev/null
+++ b/packages/fmlrunner/tests/mapping-language/data/qrext.json
@@ -0,0 +1,28 @@
+{
+ "resourceType": "QuestionnaireResponse",
+ "id": "qr-ext-1",
+ "status": "completed",
+ "item": [
+ {
+ "linkId": "weight",
+ "answer": [
+ {
+ "valueQuantity": {
+ "value": 90,
+ "unit": "kg",
+ "system": "http://unit.org",
+ "code": "kg"
+ }
+ }
+ ]
+ },
+ {
+ "linkId": "gender",
+ "answer": [
+ {
+ "valueString": "male"
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/mapping-language/maps/memberof.map b/packages/fmlrunner/tests/mapping-language/maps/memberof.map
new file mode 100644
index 0000000..f3f4990
--- /dev/null
+++ b/packages/fmlrunner/tests/mapping-language/maps/memberof.map
@@ -0,0 +1,8 @@
+map "http://ahdis.ch/matchbox/fml/memberof" = "memberof"
+
+uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as source
+uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as target
+
+group pat2pat(source src : Patient, target tgt : Patient) {
+ src.gender as gender where gender.memberOf('http://hl7.org/fhir/ValueSet/administrative-gender') -> tgt.gender = gender "rule1";
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/mapping-language/maps/narrative.map b/packages/fmlrunner/tests/mapping-language/maps/narrative.map
new file mode 100644
index 0000000..e041b0b
--- /dev/null
+++ b/packages/fmlrunner/tests/mapping-language/maps/narrative.map
@@ -0,0 +1,11 @@
+map "http://ahdis.ch/matchbox/fml/narrative" = "narrative"
+
+uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as source
+uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as target
+
+group pat2pat(source src : Patient, target tgt : Patient) {
+ src -> tgt.text = create('Narrative') as narrative then {
+ src -> narrative.status = 'generated' "status";
+ src -> narrative.div = 'text
' "div";
+ } "narrative";
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/mapping-language/maps/qr2patgender.map b/packages/fmlrunner/tests/mapping-language/maps/qr2patgender.map
new file mode 100644
index 0000000..eb1ad8c
--- /dev/null
+++ b/packages/fmlrunner/tests/mapping-language/maps/qr2patgender.map
@@ -0,0 +1,8 @@
+map "http://ahdis.ch/matchbox/fml/qr2patgender" = "qr2patgender"
+
+uses "http://hl7.org/fhir/StructureDefinition/QuestionnaireResponse" alias QuestionnaireResponse as source
+uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as target
+
+group qr2pat(source src : QuestionnaireResponse, target tgt : Patient) {
+ src.item as item where linkId = 'gender' -> tgt.gender = (item.answer.valueString) "rule1";
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/mapping-language/maps/stringtocoding.map b/packages/fmlrunner/tests/mapping-language/maps/stringtocoding.map
new file mode 100644
index 0000000..603a1d3
--- /dev/null
+++ b/packages/fmlrunner/tests/mapping-language/maps/stringtocoding.map
@@ -0,0 +1,8 @@
+map "http://ahdis.ch/matchbox/fml/stringtocoding" = "stringtocoding"
+
+uses "http://hl7.org/fhir/StructureDefinition/QuestionnaireResponse" alias QuestionnaireResponse as source
+uses "http://hl7.org/fhir/StructureDefinition/ExplanationOfBenefit" alias ExplanationOfBenefit as target
+
+group qr2eob(source src : QuestionnaireResponse, target tgt : ExplanationOfBenefit) {
+ src -> tgt.type = cc('http://terminology.hl7.org/CodeSystem/claim-type', 'oral') "type";
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/mapping-language/tutorial/step1/logical/structuredefinition-tleft.json b/packages/fmlrunner/tests/mapping-language/tutorial/step1/logical/structuredefinition-tleft.json
new file mode 100644
index 0000000..055c9ff
--- /dev/null
+++ b/packages/fmlrunner/tests/mapping-language/tutorial/step1/logical/structuredefinition-tleft.json
@@ -0,0 +1,33 @@
+{
+ "resourceType": "StructureDefinition",
+ "id": "tutorial-left-1",
+ "url": "http://hl7.org/fhir/StructureDefinition/tutorial-left-1",
+ "version": "5.0.0",
+ "name": "TutorialLeft1",
+ "status": "active",
+ "kind": "logical",
+ "abstract": false,
+ "type": "TLeft",
+ "baseDefinition": "http://hl7.org/fhir/StructureDefinition/Base",
+ "derivation": "specialization",
+ "differential": {
+ "element": [
+ {
+ "id": "TLeft",
+ "path": "TLeft",
+ "definition": "Tutorial Left Structure Step 1"
+ },
+ {
+ "id": "TLeft.a",
+ "path": "TLeft.a",
+ "min": 0,
+ "max": "1",
+ "type": [
+ {
+ "code": "string"
+ }
+ ]
+ }
+ ]
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/mapping-language/tutorial/step1/logical/structuredefinition-tright.json b/packages/fmlrunner/tests/mapping-language/tutorial/step1/logical/structuredefinition-tright.json
new file mode 100644
index 0000000..c1ed1e4
--- /dev/null
+++ b/packages/fmlrunner/tests/mapping-language/tutorial/step1/logical/structuredefinition-tright.json
@@ -0,0 +1,33 @@
+{
+ "resourceType": "StructureDefinition",
+ "id": "tutorial-right-1",
+ "url": "http://hl7.org/fhir/StructureDefinition/tutorial-right-1",
+ "version": "5.0.0",
+ "name": "TutorialRight1",
+ "status": "active",
+ "kind": "logical",
+ "abstract": false,
+ "type": "TRight",
+ "baseDefinition": "http://hl7.org/fhir/StructureDefinition/Base",
+ "derivation": "specialization",
+ "differential": {
+ "element": [
+ {
+ "id": "TRight",
+ "path": "TRight",
+ "definition": "Tutorial Right Structure Step 1"
+ },
+ {
+ "id": "TRight.a",
+ "path": "TRight.a",
+ "min": 0,
+ "max": "1",
+ "type": [
+ {
+ "code": "string"
+ }
+ ]
+ }
+ ]
+ }
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/mapping-language/tutorial/step1/map/step1.map b/packages/fmlrunner/tests/mapping-language/tutorial/step1/map/step1.map
new file mode 100644
index 0000000..d5c4ccb
--- /dev/null
+++ b/packages/fmlrunner/tests/mapping-language/tutorial/step1/map/step1.map
@@ -0,0 +1,8 @@
+map "http://hl7.org/fhir/StructureMap/tutorial-step1" = "tutorial-step1"
+
+uses "http://hl7.org/fhir/StructureDefinition/tutorial-left-1" alias TLeft as source
+uses "http://hl7.org/fhir/StructureDefinition/tutorial-right-1" alias TRight as target
+
+group tutorial(source src : TLeft, target tgt : TRight) {
+ src.a -> tgt.a;
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/mapping-language/tutorial/step1/result/step1.source1.json b/packages/fmlrunner/tests/mapping-language/tutorial/step1/result/step1.source1.json
new file mode 100644
index 0000000..b2469b6
--- /dev/null
+++ b/packages/fmlrunner/tests/mapping-language/tutorial/step1/result/step1.source1.json
@@ -0,0 +1,3 @@
+{
+ "a": "hello"
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/mapping-language/tutorial/step1/source/source1.json b/packages/fmlrunner/tests/mapping-language/tutorial/step1/source/source1.json
new file mode 100644
index 0000000..b2469b6
--- /dev/null
+++ b/packages/fmlrunner/tests/mapping-language/tutorial/step1/source/source1.json
@@ -0,0 +1,3 @@
+{
+ "a": "hello"
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/structure-map-executor.test.ts b/packages/fmlrunner/tests/structure-map-executor.test.ts
new file mode 100644
index 0000000..2b44522
--- /dev/null
+++ b/packages/fmlrunner/tests/structure-map-executor.test.ts
@@ -0,0 +1,92 @@
+import { StructureMapExecutor } from '../src/lib/structure-map-executor';
+import { StructureMap } from '../src/types';
+
+describe('StructureMapExecutor', () => {
+ let executor: StructureMapExecutor;
+
+ beforeEach(() => {
+ executor = new StructureMapExecutor();
+ });
+
+ const testStructureMap: StructureMap = {
+ resourceType: 'StructureMap',
+ name: 'TestMap',
+ status: 'active',
+ group: [
+ {
+ name: 'main',
+ input: [
+ { name: 'source', mode: 'source' },
+ { name: 'target', mode: 'target' }
+ ],
+ rule: [
+ {
+ source: [{ context: 'source', element: 'name' }],
+ target: [{ context: 'target', element: 'fullName' }]
+ }
+ ]
+ }
+ ]
+ };
+
+ describe('execute', () => {
+ it('should execute basic StructureMap transformation', () => {
+ const inputData = { name: 'John Doe' };
+ const result = executor.execute(testStructureMap, inputData);
+
+ expect(result.success).toBe(true);
+ expect(result.result).toEqual({ fullName: 'John Doe' });
+ });
+
+ it('should return error for null StructureMap', () => {
+ const result = executor.execute(null as any, {});
+
+ expect(result.success).toBe(false);
+ expect(result.errors).toContain('StructureMap is required');
+ });
+
+ it('should return error for StructureMap without groups', () => {
+ const invalidMap: StructureMap = {
+ resourceType: 'StructureMap',
+ name: 'Invalid',
+ status: 'active',
+ group: []
+ };
+
+ const result = executor.execute(invalidMap, {});
+
+ expect(result.success).toBe(false);
+ expect(result.errors).toContain('StructureMap must have at least one group');
+ });
+ });
+
+ describe('validateStructureMap', () => {
+ it('should validate correct StructureMap', () => {
+ const validation = executor.validateStructureMap(testStructureMap);
+ expect(validation.valid).toBe(true);
+ expect(validation.errors).toHaveLength(0);
+ });
+
+ it('should reject null StructureMap', () => {
+ const validation = executor.validateStructureMap(null as any);
+ expect(validation.valid).toBe(false);
+ expect(validation.errors).toContain('StructureMap is null or undefined');
+ });
+
+ it('should reject StructureMap with wrong resourceType', () => {
+ const invalidMap = { ...testStructureMap, resourceType: 'Patient' as any };
+ const validation = executor.validateStructureMap(invalidMap);
+
+ expect(validation.valid).toBe(false);
+ expect(validation.errors).toContain('Resource type must be "StructureMap"');
+ });
+
+ it('should reject StructureMap without groups', () => {
+ const invalidMap = { ...testStructureMap, group: [] };
+ const validation = executor.validateStructureMap(invalidMap);
+
+ expect(validation.valid).toBe(false);
+ expect(validation.errors).toContain('StructureMap must have at least one group');
+ });
+ });
+});
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/structure-map-retriever.test.ts b/packages/fmlrunner/tests/structure-map-retriever.test.ts
new file mode 100644
index 0000000..dd46010
--- /dev/null
+++ b/packages/fmlrunner/tests/structure-map-retriever.test.ts
@@ -0,0 +1,53 @@
+import { StructureMapRetriever } from '../src/lib/structure-map-retriever';
+import * as path from 'path';
+
+describe('StructureMapRetriever', () => {
+ let retriever: StructureMapRetriever;
+ const testDataDir = path.join(__dirname, 'test-data');
+
+ beforeEach(() => {
+ retriever = new StructureMapRetriever(testDataDir);
+ });
+
+ describe('getStructureMap', () => {
+ it('should load StructureMap from file', async () => {
+ const structureMap = await retriever.getStructureMap('test-structure-map.json');
+
+ expect(structureMap).toBeDefined();
+ expect(structureMap?.resourceType).toBe('StructureMap');
+ expect(structureMap?.name).toBe('TestMap');
+ expect(structureMap?.url).toBe('http://example.org/StructureMap/test');
+ });
+
+ it('should return null for non-existent file', async () => {
+ const structureMap = await retriever.getStructureMap('non-existent.json');
+ expect(structureMap).toBeNull();
+ });
+
+ it('should cache loaded StructureMaps', async () => {
+ const structureMap1 = await retriever.getStructureMap('test-structure-map.json');
+ const structureMap2 = await retriever.getStructureMap('test-structure-map.json');
+
+ expect(structureMap1).toBe(structureMap2); // Should be same cached instance
+ });
+
+ it('should clear cache when requested', async () => {
+ await retriever.getStructureMap('test-structure-map.json');
+ retriever.clearCache();
+
+ // Should load fresh after cache clear
+ const structureMap = await retriever.getStructureMap('test-structure-map.json');
+ expect(structureMap).toBeDefined();
+ });
+ });
+
+ describe('setBaseDirectory', () => {
+ it('should update base directory', () => {
+ const newDir = '/new/path';
+ retriever.setBaseDirectory(newDir);
+ // No direct way to test this without making baseDirectory public
+ // In a real implementation, might want to add a getter
+ expect(() => retriever.setBaseDirectory(newDir)).not.toThrow();
+ });
+ });
+});
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/test-data/test-structure-map.json b/packages/fmlrunner/tests/test-data/test-structure-map.json
new file mode 100644
index 0000000..94dd9db
--- /dev/null
+++ b/packages/fmlrunner/tests/test-data/test-structure-map.json
@@ -0,0 +1,38 @@
+{
+ "resourceType": "StructureMap",
+ "id": "test-map",
+ "url": "http://example.org/StructureMap/test",
+ "name": "TestMap",
+ "status": "active",
+ "group": [
+ {
+ "name": "main",
+ "input": [
+ {
+ "name": "source",
+ "mode": "source"
+ },
+ {
+ "name": "target",
+ "mode": "target"
+ }
+ ],
+ "rule": [
+ {
+ "source": [
+ {
+ "context": "source",
+ "element": "name"
+ }
+ ],
+ "target": [
+ {
+ "context": "target",
+ "element": "fullName"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/packages/fmlrunner/tests/validation-service.test.ts b/packages/fmlrunner/tests/validation-service.test.ts
new file mode 100644
index 0000000..2aa26c1
--- /dev/null
+++ b/packages/fmlrunner/tests/validation-service.test.ts
@@ -0,0 +1,167 @@
+import { ValidationService } from '../src/lib/validation-service';
+import { StructureDefinition } from '../src/types';
+
+describe('ValidationService', () => {
+ let validationService: ValidationService;
+
+ beforeEach(() => {
+ validationService = new ValidationService();
+ });
+
+ describe('registerStructureDefinition', () => {
+ it('should register StructureDefinition by URL', () => {
+ const structureDefinition: StructureDefinition = {
+ resourceType: 'StructureDefinition',
+ url: 'http://example.org/StructureDefinition/Patient',
+ name: 'Patient',
+ status: 'active',
+ kind: 'resource',
+ type: 'Patient'
+ };
+
+ validationService.registerStructureDefinition(structureDefinition);
+ const definitions = validationService.getStructureDefinitions();
+
+ expect(definitions.length).toBeGreaterThanOrEqual(1);
+ expect(definitions[0].name).toBe('Patient');
+ });
+
+ it('should register StructureDefinition by name', () => {
+ const structureDefinition: StructureDefinition = {
+ resourceType: 'StructureDefinition',
+ name: 'TestProfile',
+ status: 'draft',
+ kind: 'logical',
+ type: 'TestResource'
+ };
+
+ validationService.registerStructureDefinition(structureDefinition);
+ const definitions = validationService.getStructureDefinitions();
+
+ expect(definitions).toHaveLength(1);
+ expect(definitions[0].name).toBe('TestProfile');
+ });
+ });
+
+ describe('validate', () => {
+ beforeEach(() => {
+ const structureDefinition: StructureDefinition = {
+ resourceType: 'StructureDefinition',
+ url: 'http://example.org/StructureDefinition/Patient',
+ name: 'Patient',
+ status: 'active',
+ kind: 'resource',
+ type: 'Patient',
+ snapshot: {
+ element: [
+ {
+ path: 'Patient',
+ min: 1,
+ max: '1'
+ },
+ {
+ path: 'Patient.name',
+ min: 1,
+ max: '*',
+ type: [{ code: 'string' }]
+ },
+ {
+ path: 'Patient.active',
+ min: 0,
+ max: '1',
+ type: [{ code: 'boolean' }]
+ }
+ ]
+ }
+ };
+
+ validationService.registerStructureDefinition(structureDefinition);
+ });
+
+ it('should validate valid resource', () => {
+ const patient = {
+ resourceType: 'Patient',
+ name: 'John Doe',
+ active: true
+ };
+
+ const result = validationService.validate(patient, 'http://example.org/StructureDefinition/Patient');
+
+ expect(result.valid).toBe(true);
+ expect(result.errors).toHaveLength(0);
+ });
+
+ it('should detect missing required elements', () => {
+ const patient = {
+ resourceType: 'Patient',
+ active: true
+ // Missing required 'name' field
+ };
+
+ const result = validationService.validate(patient, 'http://example.org/StructureDefinition/Patient');
+
+ expect(result.valid).toBe(false);
+ expect(result.errors).toHaveLength(1);
+ expect(result.errors[0].message).toContain('Required element');
+ expect(result.errors[0].path).toBe('Patient.name');
+ });
+
+ it('should detect wrong resource type', () => {
+ const observation = {
+ resourceType: 'Observation',
+ name: 'Test'
+ };
+
+ const result = validationService.validate(observation, 'http://example.org/StructureDefinition/Patient');
+
+ expect(result.valid).toBe(false);
+ expect(result.errors).toHaveLength(1);
+ expect(result.errors[0].message).toContain('Expected resourceType');
+ });
+
+ it('should return error for unknown StructureDefinition', () => {
+ const resource = {
+ resourceType: 'Unknown'
+ };
+
+ const result = validationService.validate(resource, 'http://example.org/unknown');
+
+ expect(result.valid).toBe(false);
+ expect(result.errors).toHaveLength(1);
+ expect(result.errors[0].message).toContain('StructureDefinition not found');
+ });
+
+ it('should generate warnings for type mismatches', () => {
+ const patient = {
+ resourceType: 'Patient',
+ name: 'John Doe',
+ active: 'true' // String instead of boolean
+ };
+
+ const result = validationService.validate(patient, 'http://example.org/StructureDefinition/Patient');
+
+ expect(result.valid).toBe(true); // No errors, just warnings
+ expect(result.warnings).toHaveLength(1);
+ expect(result.warnings[0].message).toContain('may not match expected type');
+ expect(result.warnings[0].path).toBe('Patient.active');
+ });
+ });
+
+ describe('clearStructureDefinitions', () => {
+ it('should clear all registered StructureDefinitions', () => {
+ const structureDefinition: StructureDefinition = {
+ resourceType: 'StructureDefinition',
+ name: 'Test',
+ status: 'active',
+ kind: 'logical',
+ type: 'Test'
+ };
+
+ validationService.registerStructureDefinition(structureDefinition);
+ expect(validationService.getStructureDefinitions()).toHaveLength(1);
+
+ validationService.clearStructureDefinitions();
+ expect(validationService.getStructureDefinitions()).toHaveLength(0);
+ });
+ });
+});
\ No newline at end of file
diff --git a/packages/fmlrunner/tsconfig.json b/packages/fmlrunner/tsconfig.json
new file mode 100644
index 0000000..aba4d5c
--- /dev/null
+++ b/packages/fmlrunner/tsconfig.json
@@ -0,0 +1,18 @@
+{
+ "compilerOptions": {
+ "target": "ES2020",
+ "module": "commonjs",
+ "lib": ["ES2020"],
+ "outDir": "./dist",
+ "rootDir": "./src",
+ "strict": true,
+ "esModuleInterop": true,
+ "skipLibCheck": true,
+ "forceConsistentCasingInFileNames": true,
+ "declaration": true,
+ "declarationMap": true,
+ "sourceMap": true
+ },
+ "include": ["src/**/*"],
+ "exclude": ["node_modules", "dist", "tests"]
+}
\ No newline at end of file
diff --git a/scripts/version.js b/scripts/version.js
new file mode 100755
index 0000000..c66f057
--- /dev/null
+++ b/scripts/version.js
@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+
+/**
+ * Versioning utility for FML Runner monorepo
+ * Handles synchronized version updates across all packages
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const PACKAGES_DIR = path.join(__dirname, '..', 'packages');
+const ROOT_PACKAGE = path.join(__dirname, '..', 'package.json');
+
+function updatePackageVersion(packagePath, newVersion) {
+ const packageJsonPath = path.join(packagePath, 'package.json');
+ const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+ packageJson.version = newVersion;
+
+ // Update fmlrunner dependency version in other packages
+ if (packageJson.dependencies && packageJson.dependencies.fmlrunner) {
+ packageJson.dependencies.fmlrunner = `^${newVersion}`;
+ }
+
+ fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+ console.log(`โ
Updated ${path.basename(packagePath)} to version ${newVersion}`);
+}
+
+function prepareForPublishing(newVersion) {
+ console.log('๐ง Preparing packages for publishing...');
+
+ // Update all packages to use npm registry versions instead of file: paths
+ const packages = fs.readdirSync(PACKAGES_DIR, { withFileTypes: true })
+ .filter(dirent => dirent.isDirectory())
+ .map(dirent => dirent.name);
+
+ packages.forEach(packageName => {
+ if (packageName === 'fmlrunner') return; // Skip core package
+
+ const packagePath = path.join(PACKAGES_DIR, packageName);
+ const packageJsonPath = path.join(packagePath, 'package.json');
+ const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+ // Convert file: dependencies to npm registry versions
+ if (packageJson.dependencies && packageJson.dependencies.fmlrunner &&
+ packageJson.dependencies.fmlrunner.startsWith('file:')) {
+ packageJson.dependencies.fmlrunner = `^${newVersion}`;
+ fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+ console.log(`๐ Updated ${packageName} to use npm registry version`);
+ }
+ });
+}
+
+function restoreDevDependencies() {
+ console.log('๐ง Restoring development dependencies...');
+
+ const packages = ['fmlrunner-rest', 'fmlrunner-mcp', 'fmlrunner-web'];
+
+ packages.forEach(packageName => {
+ const packagePath = path.join(PACKAGES_DIR, packageName);
+ const packageJsonPath = path.join(packagePath, 'package.json');
+ const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+ // Restore file: dependencies for development
+ if (packageJson.dependencies && packageJson.dependencies.fmlrunner &&
+ !packageJson.dependencies.fmlrunner.startsWith('file:')) {
+ packageJson.dependencies.fmlrunner = 'file:../fmlrunner';
+ fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+ console.log(`๐ Restored ${packageName} to use local file dependency`);
+ }
+ });
+}
+
+function getCurrentVersion() {
+ const corePackage = path.join(PACKAGES_DIR, 'fmlrunner', 'package.json');
+ const packageJson = JSON.parse(fs.readFileSync(corePackage, 'utf8'));
+ return packageJson.version;
+}
+
+function incrementVersion(version, type) {
+ const [major, minor, patch] = version.split('.').map(Number);
+
+ switch (type) {
+ case 'major':
+ return `${major + 1}.0.0`;
+ case 'minor':
+ return `${major}.${minor + 1}.0`;
+ case 'patch':
+ return `${major}.${minor}.${patch + 1}`;
+ default:
+ throw new Error(`Invalid version type: ${type}. Use 'major', 'minor', or 'patch'.`);
+ }
+}
+
+function updateAllPackages(newVersion) {
+ // Update root package.json
+ const rootPackageJson = JSON.parse(fs.readFileSync(ROOT_PACKAGE, 'utf8'));
+ rootPackageJson.version = newVersion;
+ fs.writeFileSync(ROOT_PACKAGE, JSON.stringify(rootPackageJson, null, 2) + '\n');
+ console.log(`โ
Updated root package to version ${newVersion}`);
+
+ // Update all packages
+ const packages = fs.readdirSync(PACKAGES_DIR, { withFileTypes: true })
+ .filter(dirent => dirent.isDirectory())
+ .map(dirent => dirent.name);
+
+ packages.forEach(packageName => {
+ const packagePath = path.join(PACKAGES_DIR, packageName);
+ updatePackageVersion(packagePath, newVersion);
+ });
+}
+
+function createTag(version) {
+ try {
+ execSync(`git tag v${version}`, { stdio: 'inherit' });
+ console.log(`โ
Created git tag v${version}`);
+ } catch (error) {
+ console.error(`โ Failed to create git tag: ${error.message}`);
+ }
+}
+
+function publishPackages(dryRun = false) {
+ const dryRunFlag = dryRun ? '--dry-run' : '';
+ const version = getCurrentVersion();
+
+ console.log(`${dryRun ? '๐งช Dry run:' : '๐ฆ'} Publishing packages...`);
+
+ try {
+ // Prepare for publishing (convert to npm registry dependencies)
+ if (!dryRun) {
+ prepareForPublishing(version);
+ }
+
+ // Publish core package first
+ console.log('Publishing fmlrunner core library...');
+ execSync(`cd packages/fmlrunner && npm publish --access public ${dryRunFlag}`, { stdio: 'inherit' });
+
+ if (!dryRun) {
+ console.log('โณ Waiting for npm registry to update...');
+ execSync('sleep 10');
+ }
+
+ // Publish dependent packages
+ const dependentPackages = ['fmlrunner-rest', 'fmlrunner-mcp', 'fmlrunner-web'];
+ dependentPackages.forEach(packageName => {
+ console.log(`Publishing ${packageName}...`);
+ execSync(`cd packages/${packageName} && npm publish --access public ${dryRunFlag}`, { stdio: 'inherit' });
+ });
+
+ console.log(`โ
${dryRun ? 'Dry run completed' : 'All packages published successfully'}!`);
+
+ // Restore development dependencies
+ if (!dryRun) {
+ restoreDevDependencies();
+ }
+ } catch (error) {
+ console.error(`โ Publishing failed: ${error.message}`);
+
+ // Restore development dependencies even on failure
+ if (!dryRun) {
+ try {
+ restoreDevDependencies();
+ } catch (restoreError) {
+ console.error(`โ Failed to restore dev dependencies: ${restoreError.message}`);
+ }
+ }
+
+ process.exit(1);
+ }
+}
+
+function showUsage() {
+ console.log(`
+FML Runner Versioning Utility
+
+Usage:
+ node scripts/version.js [options]
+
+Commands:
+ current Show current version
+ bump Bump version (patch, minor, major)
+ set Set specific version
+ publish [--dry-run] Publish packages to npm
+ prepare-publish Convert file: dependencies to npm registry versions
+ restore-dev Restore file: dependencies for development
+ tag Create git tag for current version
+
+Examples:
+ node scripts/version.js current
+ node scripts/version.js bump patch
+ node scripts/version.js set 1.2.3
+ node scripts/version.js publish --dry-run
+ node scripts/version.js tag
+`);
+}
+
+// Main execution
+const [,, command, ...args] = process.argv;
+
+switch (command) {
+ case 'current':
+ console.log(`Current version: ${getCurrentVersion()}`);
+ break;
+
+ case 'bump':
+ const bumpType = args[0];
+ if (!bumpType || !['major', 'minor', 'patch'].includes(bumpType)) {
+ console.error('โ Please specify version type: major, minor, or patch');
+ process.exit(1);
+ }
+ const currentVersion = getCurrentVersion();
+ const newVersion = incrementVersion(currentVersion, bumpType);
+ console.log(`Bumping version from ${currentVersion} to ${newVersion}`);
+ updateAllPackages(newVersion);
+ break;
+
+ case 'set':
+ const targetVersion = args[0];
+ if (!targetVersion || !/^\d+\.\d+\.\d+$/.test(targetVersion)) {
+ console.error('โ Please specify a valid semantic version (e.g., 1.2.3)');
+ process.exit(1);
+ }
+ console.log(`Setting version to ${targetVersion}`);
+ updateAllPackages(targetVersion);
+ break;
+
+ case 'publish':
+ const isDryRun = args.includes('--dry-run');
+ publishPackages(isDryRun);
+ break;
+
+ case 'prepare-publish':
+ const currentVersionForPrep = getCurrentVersion();
+ prepareForPublishing(currentVersionForPrep);
+ break;
+
+ case 'restore-dev':
+ restoreDevDependencies();
+ break;
+
+ case 'tag':
+ const version = getCurrentVersion();
+ createTag(version);
+ break;
+
+ default:
+ showUsage();
+ break;
+}
\ No newline at end of file
diff --git a/src/api/server.ts b/src/api/server.ts
new file mode 100644
index 0000000..4b1a938
--- /dev/null
+++ b/src/api/server.ts
@@ -0,0 +1,1746 @@
+import express, { Request, Response } from 'express';
+import cors from 'cors';
+import { FmlRunner } from '../index';
+
+/**
+ * FML Runner API Server implementing the OpenAPI specification
+ */
+export class FmlRunnerApi {
+ private app: express.Application;
+ private fmlRunner: FmlRunner;
+
+ constructor(fmlRunner?: FmlRunner) {
+ this.app = express();
+ this.fmlRunner = fmlRunner || new FmlRunner();
+ this.setupMiddleware();
+ this.setupRoutes();
+ }
+
+ /**
+ * Setup Express middleware
+ */
+ private setupMiddleware(): void {
+ this.app.use(cors());
+ this.app.use(express.json());
+ this.app.use(express.urlencoded({ extended: true }));
+ }
+
+ /**
+ * Setup API routes according to OpenAPI specification
+ */
+ private setupRoutes(): void {
+ const apiRouter = express.Router({ caseSensitive: true });
+
+ // Legacy endpoints for backward compatibility
+ apiRouter.post('/compile', this.compileFml.bind(this));
+ apiRouter.post('/execute', this.executeStructureMap.bind(this));
+ apiRouter.get('/structuremap/:reference', this.getStructureMap.bind(this));
+
+ // FHIR Bundle processing endpoint
+ apiRouter.post('/Bundle', this.processBundle.bind(this));
+ apiRouter.get('/Bundle/summary', this.getBundleSummary.bind(this));
+
+ // FHIR-compliant ConceptMap CRUD endpoints
+ apiRouter.get('/ConceptMap', this.searchConceptMaps.bind(this));
+ apiRouter.get('/ConceptMap/:id', this.getConceptMapById.bind(this));
+ apiRouter.post('/ConceptMap', this.createConceptMap.bind(this));
+ apiRouter.put('/ConceptMap/:id', this.updateConceptMap.bind(this));
+ apiRouter.delete('/ConceptMap/:id', this.deleteConceptMap.bind(this));
+ apiRouter.post('/ConceptMap/\\$translate', this.translateOperation.bind(this));
+
+ // FHIR-compliant ValueSet CRUD endpoints
+ apiRouter.get('/ValueSet', this.searchValueSets.bind(this));
+ apiRouter.get('/ValueSet/:id', this.getValueSetById.bind(this));
+ apiRouter.post('/ValueSet', this.createValueSet.bind(this));
+ apiRouter.put('/ValueSet/:id', this.updateValueSet.bind(this));
+ apiRouter.delete('/ValueSet/:id', this.deleteValueSet.bind(this));
+ apiRouter.post('/ValueSet/:id/\\$expand', this.expandValueSetOperation.bind(this));
+ apiRouter.post('/ValueSet/:id/\\$validate-code', this.validateCodeOperation.bind(this));
+
+ // FHIR-compliant CodeSystem CRUD endpoints
+ apiRouter.get('/CodeSystem', this.searchCodeSystems.bind(this));
+ apiRouter.get('/CodeSystem/:id', this.getCodeSystemById.bind(this));
+ apiRouter.post('/CodeSystem', this.createCodeSystem.bind(this));
+ apiRouter.put('/CodeSystem/:id', this.updateCodeSystem.bind(this));
+ apiRouter.delete('/CodeSystem/:id', this.deleteCodeSystem.bind(this));
+ apiRouter.post('/CodeSystem/:id/\\$lookup', this.lookupOperation.bind(this));
+ apiRouter.post('/CodeSystem/:id/\\$subsumes', this.subsumesOperation.bind(this));
+ apiRouter.post('/CodeSystem/:id/\\$validate-code', this.validateCodeInCodeSystemOperation.bind(this));
+
+ // FHIR-compliant StructureDefinition CRUD endpoints
+ apiRouter.get('/StructureDefinition', this.searchStructureDefinitions.bind(this));
+ apiRouter.get('/StructureDefinition/:id', this.getStructureDefinitionById.bind(this));
+ apiRouter.post('/StructureDefinition', this.createStructureDefinition.bind(this));
+ apiRouter.put('/StructureDefinition/:id', this.updateStructureDefinition.bind(this));
+ apiRouter.delete('/StructureDefinition/:id', this.deleteStructureDefinition.bind(this));
+
+ // FHIR $transform operation (need to register before :id route)
+ apiRouter.post('/StructureMap/:operation(\\$transform)', this.transformOperation.bind(this));
+
+ // FHIR-compliant StructureMap CRUD endpoints
+ apiRouter.get('/StructureMap', this.searchStructureMaps.bind(this));
+ apiRouter.get('/StructureMap/:id', this.getStructureMapById.bind(this));
+ apiRouter.post('/StructureMap', this.createStructureMap.bind(this));
+ apiRouter.put('/StructureMap/:id', this.updateStructureMap.bind(this));
+ apiRouter.delete('/StructureMap/:id', this.deleteStructureMap.bind(this));
+
+ // Enhanced execution with validation
+ apiRouter.post('/execute-with-validation', this.executeWithValidation.bind(this));
+
+ // Validation endpoint
+ apiRouter.post('/validate', this.validateResource.bind(this));
+
+ // Health check endpoint
+ apiRouter.get('/health', this.healthCheck.bind(this));
+
+ this.app.use('/api/v1', apiRouter);
+ }
+
+ /**
+ * Compile FML content to StructureMap
+ */
+ private async compileFml(req: Request, res: Response): Promise {
+ try {
+ const { fmlContent } = req.body;
+
+ if (!fmlContent) {
+ res.status(400).json({
+ error: 'fmlContent is required',
+ details: 'Request body must include fmlContent property'
+ });
+ return;
+ }
+
+ const result = this.fmlRunner.compileFml(fmlContent);
+
+ if (result.success) {
+ res.json(result.structureMap);
+ } else {
+ res.status(400).json({
+ error: 'FML compilation failed',
+ details: result.errors?.join(', ')
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ error: 'Internal server error',
+ details: error instanceof Error ? error.message : 'Unknown error'
+ });
+ }
+ }
+
+ /**
+ * Execute StructureMap transformation
+ */
+ private async executeStructureMap(req: Request, res: Response): Promise {
+ try {
+ const { structureMapReference, inputContent } = req.body;
+
+ if (!structureMapReference || !inputContent) {
+ res.status(400).json({
+ error: 'structureMapReference and inputContent are required',
+ details: 'Request body must include both structureMapReference and inputContent properties'
+ });
+ return;
+ }
+
+ const result = await this.fmlRunner.executeStructureMap(structureMapReference, inputContent);
+
+ if (result.success) {
+ res.json({ result: result.result });
+ } else {
+ res.status(400).json({
+ error: 'StructureMap execution failed',
+ details: result.errors?.join(', ')
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ error: 'Internal server error',
+ details: error instanceof Error ? error.message : 'Unknown error'
+ });
+ }
+ }
+
+ /**
+ * Retrieve StructureMap by reference
+ */
+ private async getStructureMap(req: Request, res: Response): Promise {
+ try {
+ const { reference } = req.params;
+
+ if (!reference) {
+ res.status(400).json({
+ error: 'Reference parameter is required'
+ });
+ return;
+ }
+
+ const structureMap = await this.fmlRunner.getStructureMap(reference);
+
+ if (structureMap) {
+ res.json(structureMap);
+ } else {
+ res.status(404).json({
+ error: 'StructureMap not found',
+ details: `No StructureMap found for reference: ${reference}`
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ error: 'Internal server error',
+ details: error instanceof Error ? error.message : 'Unknown error'
+ });
+ }
+ }
+
+ /**
+ * Search StructureMaps with FHIR search parameters
+ */
+ private async searchStructureMaps(req: Request, res: Response): Promise {
+ try {
+ // FHIR search parameters - basic implementation
+ const { name, status, url, _count = '20', _offset = '0' } = req.query;
+
+ // For now, return empty bundle - would need database/storage implementation
+ const bundle = {
+ resourceType: 'Bundle',
+ type: 'searchset',
+ total: 0,
+ entry: []
+ };
+
+ res.json(bundle);
+ } catch (error) {
+ res.status(500).json({
+ error: 'Internal server error',
+ details: error instanceof Error ? error.message : 'Unknown error'
+ });
+ }
+ }
+
+ /**
+ * Get StructureMap by ID (FHIR-compliant)
+ */
+ private async getStructureMapById(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+
+ // First check registered StructureMaps in memory
+ const registeredMaps = this.fmlRunner.getAllStructureMaps();
+ let structureMap: any = registeredMaps.find(sm => sm.id === id || sm.url === id);
+
+ // If not found in memory, try file system
+ if (!structureMap) {
+ const retrieved = await this.fmlRunner.getStructureMap(id);
+ structureMap = retrieved || null;
+ }
+
+ if (structureMap) {
+ res.json(structureMap);
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `StructureMap with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Create new StructureMap (FHIR-compliant)
+ */
+ private async createStructureMap(req: Request, res: Response): Promise {
+ try {
+ const structureMap = req.body;
+
+ // Basic validation
+ if (!structureMap || structureMap.resourceType !== 'StructureMap') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid StructureMap resource'
+ }]
+ });
+ return;
+ }
+
+ // Assign ID if not present
+ if (!structureMap.id) {
+ structureMap.id = 'sm-' + Date.now();
+ }
+
+ // TODO: Store the StructureMap (would need storage implementation)
+
+ res.status(201).json(structureMap);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Update StructureMap (FHIR-compliant)
+ */
+ private async updateStructureMap(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const structureMap = req.body;
+
+ // Basic validation
+ if (!structureMap || structureMap.resourceType !== 'StructureMap') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid StructureMap resource'
+ }]
+ });
+ return;
+ }
+
+ // Ensure ID matches
+ structureMap.id = id;
+
+ // TODO: Store the StructureMap (would need storage implementation)
+
+ res.json(structureMap);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Delete StructureMap (FHIR-compliant)
+ */
+ private async deleteStructureMap(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+
+ // TODO: Delete the StructureMap (would need storage implementation)
+
+ res.status(204).send();
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * FHIR $transform operation
+ */
+ private async transformOperation(req: Request, res: Response): Promise {
+ try {
+ const parameters = req.body;
+
+ // Validate Parameters resource
+ if (!parameters || parameters.resourceType !== 'Parameters') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a FHIR Parameters resource'
+ }]
+ });
+ return;
+ }
+
+ // Extract source data and StructureMap URL from parameters
+ let sourceData = null;
+ let structureMapUrl = null;
+
+ if (parameters.parameter) {
+ for (const param of parameters.parameter) {
+ if (param.name === 'source') {
+ sourceData = param.resource || param.valueString;
+ } else if (param.name === 'map') {
+ structureMapUrl = param.valueUri || param.valueString;
+ }
+ }
+ }
+
+ if (!sourceData || !structureMapUrl) {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Parameters must include both "source" and "map" parameters'
+ }]
+ });
+ return;
+ }
+
+ // Execute transformation using existing logic
+ const result = await this.fmlRunner.executeStructureMap(structureMapUrl, sourceData);
+
+ if (result.success) {
+ // Return result as Parameters resource
+ const resultParameters = {
+ resourceType: 'Parameters',
+ parameter: [{
+ name: 'result',
+ resource: result.result
+ }]
+ };
+ res.json(resultParameters);
+ } else {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'processing',
+ diagnostics: result.errors?.join(', ') || 'Transformation failed'
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Search StructureDefinitions with FHIR search parameters
+ */
+ private async searchStructureDefinitions(req: Request, res: Response): Promise {
+ try {
+ // FHIR search parameters - basic implementation
+ const { name, status, kind, type, _count = '20', _offset = '0' } = req.query;
+
+ // Get registered StructureDefinitions from validation service
+ const validationService = this.fmlRunner.getValidationService();
+ const structureDefinitions = validationService ? validationService.getStructureDefinitions() : [];
+
+ // Filter based on search parameters (basic implementation)
+ let filteredDefinitions = structureDefinitions;
+
+ if (name) {
+ filteredDefinitions = filteredDefinitions.filter(sd =>
+ sd.name?.toLowerCase().includes((name as string).toLowerCase())
+ );
+ }
+
+ if (status) {
+ filteredDefinitions = filteredDefinitions.filter(sd => sd.status === status);
+ }
+
+ const bundle = {
+ resourceType: 'Bundle',
+ type: 'searchset',
+ total: filteredDefinitions.length,
+ entry: filteredDefinitions.map(sd => ({
+ resource: sd
+ }))
+ };
+
+ res.json(bundle);
+ } catch (error) {
+ res.status(500).json({
+ error: 'Internal server error',
+ details: error instanceof Error ? error.message : 'Unknown error'
+ });
+ }
+ }
+
+ /**
+ * Get StructureDefinition by ID
+ */
+ private async getStructureDefinitionById(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+
+ // This would need a proper storage implementation
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `StructureDefinition with id '${id}' not found`
+ }]
+ });
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Create new StructureDefinition
+ */
+ private async createStructureDefinition(req: Request, res: Response): Promise {
+ try {
+ const structureDefinition = req.body;
+
+ // Basic validation
+ if (!structureDefinition || structureDefinition.resourceType !== 'StructureDefinition') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid StructureDefinition resource'
+ }]
+ });
+ return;
+ }
+
+ // Assign ID if not present
+ if (!structureDefinition.id) {
+ structureDefinition.id = 'sd-' + Date.now();
+ }
+
+ // Register with validation service
+ const validationService = this.fmlRunner.getValidationService();
+ if (validationService) {
+ validationService.registerStructureDefinition(structureDefinition);
+ }
+
+ res.status(201).json(structureDefinition);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Update StructureDefinition
+ */
+ private async updateStructureDefinition(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const structureDefinition = req.body;
+
+ // Basic validation
+ if (!structureDefinition || structureDefinition.resourceType !== 'StructureDefinition') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid StructureDefinition resource'
+ }]
+ });
+ return;
+ }
+
+ // Ensure ID matches
+ structureDefinition.id = id;
+
+ // Register with validation service
+ const validationService = this.fmlRunner.getValidationService();
+ if (validationService) {
+ validationService.registerStructureDefinition(structureDefinition);
+ }
+
+ res.json(structureDefinition);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Delete StructureDefinition
+ */
+ private async deleteStructureDefinition(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+
+ // TODO: Remove from validation service
+
+ res.status(204).send();
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Execute StructureMap with validation
+ */
+ private async executeWithValidation(req: Request, res: Response): Promise {
+ try {
+ const { structureMapReference, inputContent, options } = req.body;
+
+ if (!structureMapReference || !inputContent) {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'structureMapReference and inputContent are required'
+ }]
+ });
+ return;
+ }
+
+ const result = await this.fmlRunner.executeStructureMapWithValidation(
+ structureMapReference,
+ inputContent,
+ options
+ );
+
+ if (result.success) {
+ res.json({
+ result: result.result,
+ validation: result.validation
+ });
+ } else {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'processing',
+ diagnostics: result.errors?.join(', ') || 'Execution failed'
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Validate a resource against a StructureDefinition
+ */
+ private async validateResource(req: Request, res: Response): Promise {
+ try {
+ const { resource, profile } = req.body;
+
+ if (!resource || !profile) {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Both resource and profile are required'
+ }]
+ });
+ return;
+ }
+
+ const validationService = this.fmlRunner.getValidationService();
+ if (!validationService) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-supported',
+ diagnostics: 'Validation service not available'
+ }]
+ });
+ return;
+ }
+
+ const validationResult = validationService.validate(resource, profile);
+
+ const operationOutcome = {
+ resourceType: 'OperationOutcome',
+ issue: [
+ ...validationResult.errors.map(error => ({
+ severity: 'error' as const,
+ code: 'invariant' as const,
+ diagnostics: error.message,
+ location: [error.path]
+ })),
+ ...validationResult.warnings.map(warning => ({
+ severity: 'warning' as const,
+ code: 'informational' as const,
+ diagnostics: warning.message,
+ location: [warning.path]
+ }))
+ ]
+ };
+
+ if (validationResult.valid) {
+ res.json(operationOutcome);
+ } else {
+ res.status(400).json(operationOutcome);
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Health check endpoint
+ */
+ private healthCheck(req: Request, res: Response): void {
+ res.json({
+ status: 'healthy',
+ timestamp: new Date().toISOString(),
+ version: '0.1.0',
+ resources: this.fmlRunner.getBundleStats()
+ });
+ }
+
+ // ============================================
+ // BUNDLE PROCESSING ENDPOINTS
+ // ============================================
+
+ /**
+ * Process FHIR Bundle and load resources
+ */
+ private async processBundle(req: Request, res: Response): Promise {
+ try {
+ const bundle = req.body;
+
+ if (!bundle || bundle.resourceType !== 'Bundle') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid Bundle resource'
+ }]
+ });
+ return;
+ }
+
+ const result = this.fmlRunner.processBundle(bundle);
+
+ if (result.success) {
+ res.status(201).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'information',
+ code: 'informational',
+ diagnostics: `Successfully processed bundle. Loaded: ${result.processed.structureMaps} StructureMaps, ${result.processed.structureDefinitions} StructureDefinitions, ${result.processed.conceptMaps} ConceptMaps, ${result.processed.valueSets} ValueSets, ${result.processed.codeSystems} CodeSystems`
+ }]
+ });
+ } else {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'processing',
+ diagnostics: `Bundle processing failed: ${result.errors.join(', ')}`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Get bundle summary of loaded resources
+ */
+ private async getBundleSummary(req: Request, res: Response): Promise {
+ try {
+ const summaryBundle = this.fmlRunner.createResourceSummaryBundle();
+ res.json(summaryBundle);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ // ============================================
+ // CONCEPTMAP CRUD ENDPOINTS
+ // ============================================
+
+ /**
+ * Search ConceptMaps
+ */
+ private async searchConceptMaps(req: Request, res: Response): Promise {
+ try {
+ const { name, status, url, source, target, _count = '20', _offset = '0' } = req.query;
+
+ const conceptMaps = this.fmlRunner.searchConceptMaps({
+ name: name as string,
+ status: status as string,
+ url: url as string,
+ source: source as string,
+ target: target as string
+ });
+
+ const bundle = {
+ resourceType: 'Bundle',
+ type: 'searchset',
+ total: conceptMaps.length,
+ entry: conceptMaps.map(cm => ({
+ resource: cm
+ }))
+ };
+
+ res.json(bundle);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Get ConceptMap by ID
+ */
+ private async getConceptMapById(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const conceptMap = this.fmlRunner.getConceptMap(id);
+
+ if (conceptMap) {
+ res.json(conceptMap);
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `ConceptMap with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Create ConceptMap
+ */
+ private async createConceptMap(req: Request, res: Response): Promise {
+ try {
+ const conceptMap = req.body;
+
+ if (!conceptMap || conceptMap.resourceType !== 'ConceptMap') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid ConceptMap resource'
+ }]
+ });
+ return;
+ }
+
+ if (!conceptMap.id) {
+ conceptMap.id = 'cm-' + Date.now();
+ }
+
+ this.fmlRunner.registerConceptMap(conceptMap);
+ res.status(201).json(conceptMap);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Update ConceptMap
+ */
+ private async updateConceptMap(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const conceptMap = req.body;
+
+ if (!conceptMap || conceptMap.resourceType !== 'ConceptMap') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid ConceptMap resource'
+ }]
+ });
+ return;
+ }
+
+ conceptMap.id = id;
+ this.fmlRunner.registerConceptMap(conceptMap);
+ res.json(conceptMap);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Delete ConceptMap
+ */
+ private async deleteConceptMap(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const success = this.fmlRunner.removeConceptMap(id);
+
+ if (success) {
+ res.status(204).send();
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `ConceptMap with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * ConceptMap $translate operation
+ */
+ private async translateOperation(req: Request, res: Response): Promise {
+ try {
+ const parameters = req.body;
+
+ if (!parameters || parameters.resourceType !== 'Parameters') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a FHIR Parameters resource'
+ }]
+ });
+ return;
+ }
+
+ let system: string | undefined;
+ let code: string | undefined;
+ let target: string | undefined;
+
+ if (parameters.parameter) {
+ for (const param of parameters.parameter) {
+ if (param.name === 'system') {
+ system = param.valueUri || param.valueString;
+ } else if (param.name === 'code') {
+ code = param.valueCode || param.valueString;
+ } else if (param.name === 'target') {
+ target = param.valueUri || param.valueString;
+ }
+ }
+ }
+
+ if (!system || !code) {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Parameters must include both "system" and "code" parameters'
+ }]
+ });
+ return;
+ }
+
+ const translations = this.fmlRunner.translateCode(system, code, target);
+
+ const resultParameters = {
+ resourceType: 'Parameters',
+ parameter: translations.map(t => ({
+ name: 'match',
+ part: [
+ { name: 'equivalence', valueCode: t.equivalence },
+ ...(t.system ? [{ name: 'concept', valueCoding: { system: t.system, code: t.code, display: t.display } }] : [])
+ ]
+ }))
+ };
+
+ res.json(resultParameters);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ // ============================================
+ // VALUESET CRUD ENDPOINTS
+ // ============================================
+
+ /**
+ * Search ValueSets
+ */
+ private async searchValueSets(req: Request, res: Response): Promise {
+ try {
+ const { name, status, url, publisher, jurisdiction, _count = '20', _offset = '0' } = req.query;
+
+ const valueSets = this.fmlRunner.searchValueSets({
+ name: name as string,
+ status: status as string,
+ url: url as string,
+ publisher: publisher as string,
+ jurisdiction: jurisdiction as string
+ });
+
+ const bundle = {
+ resourceType: 'Bundle',
+ type: 'searchset',
+ total: valueSets.length,
+ entry: valueSets.map(vs => ({
+ resource: vs
+ }))
+ };
+
+ res.json(bundle);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Get ValueSet by ID
+ */
+ private async getValueSetById(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const valueSet = this.fmlRunner.getValueSet(id);
+
+ if (valueSet) {
+ res.json(valueSet);
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `ValueSet with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Create ValueSet
+ */
+ private async createValueSet(req: Request, res: Response): Promise {
+ try {
+ const valueSet = req.body;
+
+ if (!valueSet || valueSet.resourceType !== 'ValueSet') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid ValueSet resource'
+ }]
+ });
+ return;
+ }
+
+ if (!valueSet.id) {
+ valueSet.id = 'vs-' + Date.now();
+ }
+
+ this.fmlRunner.registerValueSet(valueSet);
+ res.status(201).json(valueSet);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Update ValueSet
+ */
+ private async updateValueSet(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const valueSet = req.body;
+
+ if (!valueSet || valueSet.resourceType !== 'ValueSet') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid ValueSet resource'
+ }]
+ });
+ return;
+ }
+
+ valueSet.id = id;
+ this.fmlRunner.registerValueSet(valueSet);
+ res.json(valueSet);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Delete ValueSet
+ */
+ private async deleteValueSet(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const success = this.fmlRunner.removeValueSet(id);
+
+ if (success) {
+ res.status(204).send();
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `ValueSet with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * ValueSet $expand operation
+ */
+ private async expandValueSetOperation(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const parameters = req.body;
+
+ let count: number | undefined;
+ let offset: number | undefined;
+
+ if (parameters?.parameter) {
+ for (const param of parameters.parameter) {
+ if (param.name === 'count') {
+ count = param.valueInteger;
+ } else if (param.name === 'offset') {
+ offset = param.valueInteger;
+ }
+ }
+ }
+
+ const expandedValueSet = this.fmlRunner.expandValueSet(id, count, offset);
+
+ if (expandedValueSet) {
+ res.json(expandedValueSet);
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `ValueSet with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * ValueSet $validate-code operation
+ */
+ private async validateCodeOperation(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const parameters = req.body;
+
+ let system: string | undefined;
+ let code: string | undefined;
+ let display: string | undefined;
+
+ if (parameters?.parameter) {
+ for (const param of parameters.parameter) {
+ if (param.name === 'system') {
+ system = param.valueUri || param.valueString;
+ } else if (param.name === 'code') {
+ code = param.valueCode || param.valueString;
+ } else if (param.name === 'display') {
+ display = param.valueString;
+ }
+ }
+ }
+
+ const validation = this.fmlRunner.validateCodeInValueSet(id, system, code, display);
+
+ const resultParameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'result', valueBoolean: validation.result },
+ ...(validation.message ? [{ name: 'message', valueString: validation.message }] : [])
+ ]
+ };
+
+ res.json(resultParameters);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ // ============================================
+ // CODESYSTEM CRUD ENDPOINTS
+ // ============================================
+
+ /**
+ * Search CodeSystems
+ */
+ private async searchCodeSystems(req: Request, res: Response): Promise {
+ try {
+ const { name, status, url, system, publisher, content, _count = '20', _offset = '0' } = req.query;
+
+ const codeSystems = this.fmlRunner.searchCodeSystems({
+ name: name as string,
+ status: status as string,
+ url: url as string,
+ system: system as string,
+ publisher: publisher as string,
+ content: content as string
+ });
+
+ const bundle = {
+ resourceType: 'Bundle',
+ type: 'searchset',
+ total: codeSystems.length,
+ entry: codeSystems.map(cs => ({
+ resource: cs
+ }))
+ };
+
+ res.json(bundle);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Get CodeSystem by ID
+ */
+ private async getCodeSystemById(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const codeSystem = this.fmlRunner.getCodeSystem(id);
+
+ if (codeSystem) {
+ res.json(codeSystem);
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `CodeSystem with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Create CodeSystem
+ */
+ private async createCodeSystem(req: Request, res: Response): Promise {
+ try {
+ const codeSystem = req.body;
+
+ if (!codeSystem || codeSystem.resourceType !== 'CodeSystem') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid CodeSystem resource'
+ }]
+ });
+ return;
+ }
+
+ if (!codeSystem.id) {
+ codeSystem.id = 'cs-' + Date.now();
+ }
+
+ this.fmlRunner.registerCodeSystem(codeSystem);
+ res.status(201).json(codeSystem);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Update CodeSystem
+ */
+ private async updateCodeSystem(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const codeSystem = req.body;
+
+ if (!codeSystem || codeSystem.resourceType !== 'CodeSystem') {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Request body must be a valid CodeSystem resource'
+ }]
+ });
+ return;
+ }
+
+ codeSystem.id = id;
+ this.fmlRunner.registerCodeSystem(codeSystem);
+ res.json(codeSystem);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Delete CodeSystem
+ */
+ private async deleteCodeSystem(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const success = this.fmlRunner.removeCodeSystem(id);
+
+ if (success) {
+ res.status(204).send();
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `CodeSystem with id '${id}' not found`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * CodeSystem $lookup operation
+ */
+ private async lookupOperation(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const parameters = req.body;
+
+ let code: string | undefined;
+ let property: string[] | undefined;
+
+ if (parameters?.parameter) {
+ for (const param of parameters.parameter) {
+ if (param.name === 'code') {
+ code = param.valueCode || param.valueString;
+ } else if (param.name === 'property') {
+ property = property || [];
+ property.push(param.valueCode || param.valueString);
+ }
+ }
+ }
+
+ if (!code) {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Parameters must include "code" parameter'
+ }]
+ });
+ return;
+ }
+
+ const lookup = this.fmlRunner.lookupConcept(id, code, property);
+
+ if (lookup) {
+ const resultParameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'name', valueString: lookup.name },
+ ...(lookup.display ? [{ name: 'display', valueString: lookup.display }] : []),
+ ...(lookup.definition ? [{ name: 'definition', valueString: lookup.definition }] : []),
+ ...(lookup.designation ? lookup.designation.map((d: any) => ({
+ name: 'designation',
+ part: [
+ ...(d.language ? [{ name: 'language', valueCode: d.language }] : []),
+ ...(d.use ? [{ name: 'use', valueCoding: d.use }] : []),
+ { name: 'value', valueString: d.value }
+ ]
+ })) : []),
+ ...(lookup.property ? lookup.property.map((p: any) => ({
+ name: 'property',
+ part: [
+ { name: 'code', valueCode: p.code },
+ ...(p.valueCode ? [{ name: 'value', valueCode: p.valueCode }] : []),
+ ...(p.valueString ? [{ name: 'value', valueString: p.valueString }] : []),
+ ...(p.valueInteger ? [{ name: 'value', valueInteger: p.valueInteger }] : []),
+ ...(p.valueBoolean !== undefined ? [{ name: 'value', valueBoolean: p.valueBoolean }] : [])
+ ]
+ })) : [])
+ ]
+ };
+
+ res.json(resultParameters);
+ } else {
+ res.status(404).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'not-found',
+ diagnostics: `Code '${code}' not found in CodeSystem '${id}'`
+ }]
+ });
+ }
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * CodeSystem $subsumes operation
+ */
+ private async subsumesOperation(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const parameters = req.body;
+
+ let codeA: string | undefined;
+ let codeB: string | undefined;
+
+ if (parameters?.parameter) {
+ for (const param of parameters.parameter) {
+ if (param.name === 'codeA') {
+ codeA = param.valueCode || param.valueString;
+ } else if (param.name === 'codeB') {
+ codeB = param.valueCode || param.valueString;
+ }
+ }
+ }
+
+ if (!codeA || !codeB) {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Parameters must include both "codeA" and "codeB" parameters'
+ }]
+ });
+ return;
+ }
+
+ const result = this.fmlRunner.testSubsumption(id, codeA, codeB);
+
+ const resultParameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'outcome', valueCode: result }
+ ]
+ };
+
+ res.json(resultParameters);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * CodeSystem $validate-code operation
+ */
+ private async validateCodeInCodeSystemOperation(req: Request, res: Response): Promise {
+ try {
+ const { id } = req.params;
+ const parameters = req.body;
+
+ let code: string | undefined;
+ let display: string | undefined;
+
+ if (parameters?.parameter) {
+ for (const param of parameters.parameter) {
+ if (param.name === 'code') {
+ code = param.valueCode || param.valueString;
+ } else if (param.name === 'display') {
+ display = param.valueString;
+ }
+ }
+ }
+
+ if (!code) {
+ res.status(400).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'invalid',
+ diagnostics: 'Parameters must include "code" parameter'
+ }]
+ });
+ return;
+ }
+
+ const validation = this.fmlRunner.validateCodeInCodeSystem(id, code, display);
+
+ const resultParameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'result', valueBoolean: validation.result },
+ ...(validation.display ? [{ name: 'display', valueString: validation.display }] : []),
+ ...(validation.message ? [{ name: 'message', valueString: validation.message }] : [])
+ ]
+ };
+
+ res.json(resultParameters);
+ } catch (error) {
+ res.status(500).json({
+ resourceType: 'OperationOutcome',
+ issue: [{
+ severity: 'error',
+ code: 'exception',
+ diagnostics: error instanceof Error ? error.message : 'Unknown error'
+ }]
+ });
+ }
+ }
+
+ /**
+ * Get Express application instance
+ */
+ getApp(): express.Application {
+ return this.app;
+ }
+
+ /**
+ * Start the server
+ */
+ listen(port: number = 3000): void {
+ this.app.listen(port, () => {
+ console.log(`FML Runner API server listening on port ${port}`);
+ });
+ }
+}
\ No newline at end of file
diff --git a/src/index.ts b/src/index.ts
new file mode 100644
index 0000000..44b1bea
--- /dev/null
+++ b/src/index.ts
@@ -0,0 +1,520 @@
+import { FmlCompiler } from './lib/fml-compiler';
+import { StructureMapRetriever } from './lib/structure-map-retriever';
+import { StructureMapExecutor } from './lib/structure-map-executor';
+import { ValidationService } from './lib/validation-service';
+import { ConceptMapService } from './lib/conceptmap-service';
+import { ValueSetService } from './lib/valueset-service';
+import { CodeSystemService } from './lib/codesystem-service';
+import { BundleService, BundleProcessingResult } from './lib/bundle-service';
+import {
+ StructureMap,
+ FmlCompilationResult,
+ ExecutionResult,
+ EnhancedExecutionResult,
+ ExecutionOptions,
+ FmlRunnerOptions,
+ StructureDefinition,
+ ConceptMap,
+ ValueSet,
+ CodeSystem,
+ Bundle
+} from './types';
+
+/**
+ * Main FmlRunner class providing FML compilation and StructureMap execution
+ */
+export class FmlRunner {
+ private compiler: FmlCompiler;
+ private retriever: StructureMapRetriever;
+ private executor: StructureMapExecutor;
+ private conceptMapService: ConceptMapService;
+ private valueSetService: ValueSetService;
+ private codeSystemService: CodeSystemService;
+ private bundleService: BundleService;
+ private structureMapStore: Map = new Map();
+ private options: FmlRunnerOptions;
+
+ constructor(options: FmlRunnerOptions = {}) {
+ this.compiler = new FmlCompiler();
+ this.retriever = new StructureMapRetriever();
+ this.executor = new StructureMapExecutor();
+ this.conceptMapService = new ConceptMapService();
+ this.valueSetService = new ValueSetService();
+ this.codeSystemService = new CodeSystemService();
+
+ // Create bundle service with references to all resource services
+ this.bundleService = new BundleService(
+ this.conceptMapService,
+ this.valueSetService,
+ this.codeSystemService,
+ this.executor.getValidationService(),
+ this.structureMapStore
+ );
+
+ this.options = {
+ cacheEnabled: true,
+ timeout: 5000,
+ strictMode: false,
+ ...options
+ };
+
+ // Set base URL for retriever if provided
+ if (options.baseUrl) {
+ this.retriever.setBaseDirectory(options.baseUrl);
+ }
+
+ // Enhance executor with terminology services
+ this.executor.setTerminologyServices(
+ this.conceptMapService,
+ this.valueSetService,
+ this.codeSystemService
+ );
+ }
+
+ /**
+ * Compile FML content to StructureMap
+ */
+ compileFml(fmlContent: string): FmlCompilationResult {
+ return this.compiler.compile(fmlContent);
+ }
+
+ /**
+ * Execute StructureMap on input content
+ */
+ async executeStructureMap(structureMapReference: string, inputContent: any): Promise {
+ try {
+ // Retrieve the StructureMap
+ const structureMap = await this.retriever.getStructureMap(structureMapReference);
+
+ if (!structureMap) {
+ return {
+ success: false,
+ errors: [`StructureMap not found: ${structureMapReference}`]
+ };
+ }
+
+ // Validate the StructureMap
+ const validation = this.executor.validateStructureMap(structureMap);
+ if (!validation.valid) {
+ return {
+ success: false,
+ errors: [`Invalid StructureMap: ${validation.errors.join(', ')}`]
+ };
+ }
+
+ // Execute the transformation
+ return this.executor.execute(structureMap, inputContent);
+ } catch (error) {
+ return {
+ success: false,
+ errors: [error instanceof Error ? error.message : 'Unknown execution error']
+ };
+ }
+ }
+
+ /**
+ * Execute StructureMap with validation support
+ */
+ async executeStructureMapWithValidation(
+ structureMapReference: string,
+ inputContent: any,
+ options?: ExecutionOptions
+ ): Promise {
+ try {
+ // Retrieve the StructureMap
+ const structureMap = await this.retriever.getStructureMap(structureMapReference);
+
+ if (!structureMap) {
+ return {
+ success: false,
+ errors: [`StructureMap not found: ${structureMapReference}`]
+ };
+ }
+
+ // Validate the StructureMap
+ const validation = this.executor.validateStructureMap(structureMap);
+ if (!validation.valid) {
+ return {
+ success: false,
+ errors: [`Invalid StructureMap: ${validation.errors.join(', ')}`]
+ };
+ }
+
+ // Execute the transformation with validation
+ const mergedOptions = {
+ strictMode: this.options.strictMode,
+ ...options
+ };
+
+ return this.executor.execute(structureMap, inputContent, mergedOptions);
+ } catch (error) {
+ return {
+ success: false,
+ errors: [error instanceof Error ? error.message : 'Unknown execution error']
+ };
+ }
+ }
+
+ /**
+ * Register a StructureDefinition for validation
+ */
+ registerStructureDefinition(structureDefinition: StructureDefinition): void {
+ const validationService = this.executor.getValidationService();
+ validationService.registerStructureDefinition(structureDefinition);
+ }
+
+ /**
+ * Get the validation service
+ */
+ getValidationService(): ValidationService | null {
+ return this.executor.getValidationService();
+ }
+
+ /**
+ * Retrieve StructureMap by reference
+ */
+ async getStructureMap(reference: string): Promise {
+ return this.retriever.getStructureMap(reference);
+ }
+
+ /**
+ * Clear all internal caches
+ */
+ clearCache(): void {
+ this.retriever.clearCache();
+ }
+
+ /**
+ * Set base directory for StructureMap file loading
+ */
+ setBaseDirectory(directory: string): void {
+ this.retriever.setBaseDirectory(directory);
+ }
+
+ // ============================================
+ // LIBRARY API METHODS FOR RESOURCE MANAGEMENT
+ // ============================================
+
+ /**
+ * Process a FHIR Bundle and load all resources
+ */
+ processBundle(bundle: Bundle): BundleProcessingResult {
+ return this.bundleService.processBundle(bundle);
+ }
+
+ /**
+ * Get bundle processing statistics
+ */
+ getBundleStats(): {
+ structureMaps: number;
+ structureDefinitions: number;
+ conceptMaps: number;
+ valueSets: number;
+ codeSystems: number;
+ } {
+ return this.bundleService.getStats();
+ }
+
+ /**
+ * Create a summary bundle of all loaded resources
+ */
+ createResourceSummaryBundle(): Bundle {
+ return this.bundleService.createSummaryBundle();
+ }
+
+ /**
+ * Clear all loaded resources
+ */
+ clearAllResources(): void {
+ this.bundleService.clearAll();
+ }
+
+ // ============================================
+ // CONCEPTMAP LIBRARY API METHODS
+ // ============================================
+
+ /**
+ * Register a ConceptMap resource
+ */
+ registerConceptMap(conceptMap: ConceptMap): void {
+ this.conceptMapService.registerConceptMap(conceptMap);
+ }
+
+ /**
+ * Get ConceptMap by ID or URL
+ */
+ getConceptMap(reference: string): ConceptMap | null {
+ return this.conceptMapService.getConceptMap(reference);
+ }
+
+ /**
+ * Get all registered ConceptMaps
+ */
+ getAllConceptMaps(): ConceptMap[] {
+ return this.conceptMapService.getAllConceptMaps();
+ }
+
+ /**
+ * Search ConceptMaps by parameters
+ */
+ searchConceptMaps(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ source?: string;
+ target?: string;
+ }): ConceptMap[] {
+ return this.conceptMapService.searchConceptMaps(params);
+ }
+
+ /**
+ * Remove ConceptMap by ID or URL
+ */
+ removeConceptMap(reference: string): boolean {
+ return this.conceptMapService.removeConceptMap(reference);
+ }
+
+ /**
+ * Translate a code using loaded ConceptMaps
+ */
+ translateCode(
+ sourceSystem: string,
+ sourceCode: string,
+ targetSystem?: string
+ ): Array<{ system?: string; code?: string; display?: string; equivalence: string }> {
+ return this.conceptMapService.translate(sourceSystem, sourceCode, targetSystem);
+ }
+
+ // ============================================
+ // VALUESET LIBRARY API METHODS
+ // ============================================
+
+ /**
+ * Register a ValueSet resource
+ */
+ registerValueSet(valueSet: ValueSet): void {
+ this.valueSetService.registerValueSet(valueSet);
+ }
+
+ /**
+ * Get ValueSet by ID or URL
+ */
+ getValueSet(reference: string): ValueSet | null {
+ return this.valueSetService.getValueSet(reference);
+ }
+
+ /**
+ * Get all registered ValueSets
+ */
+ getAllValueSets(): ValueSet[] {
+ return this.valueSetService.getAllValueSets();
+ }
+
+ /**
+ * Search ValueSets by parameters
+ */
+ searchValueSets(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ publisher?: string;
+ jurisdiction?: string;
+ }): ValueSet[] {
+ return this.valueSetService.searchValueSets(params);
+ }
+
+ /**
+ * Remove ValueSet by ID or URL
+ */
+ removeValueSet(reference: string): boolean {
+ return this.valueSetService.removeValueSet(reference);
+ }
+
+ /**
+ * Validate a code against a ValueSet
+ */
+ validateCodeInValueSet(
+ valueSetRef: string,
+ system?: string,
+ code?: string,
+ display?: string
+ ): { result: boolean; message?: string } {
+ return this.valueSetService.validateCode(valueSetRef, system, code, display);
+ }
+
+ /**
+ * Expand a ValueSet
+ */
+ expandValueSet(valueSetRef: string, count?: number, offset?: number): ValueSet | null {
+ return this.valueSetService.expand(valueSetRef, count, offset);
+ }
+
+ // ============================================
+ // CODESYSTEM LIBRARY API METHODS
+ // ============================================
+
+ /**
+ * Register a CodeSystem resource
+ */
+ registerCodeSystem(codeSystem: CodeSystem): void {
+ this.codeSystemService.registerCodeSystem(codeSystem);
+ }
+
+ /**
+ * Get CodeSystem by ID or URL
+ */
+ getCodeSystem(reference: string): CodeSystem | null {
+ return this.codeSystemService.getCodeSystem(reference);
+ }
+
+ /**
+ * Get all registered CodeSystems
+ */
+ getAllCodeSystems(): CodeSystem[] {
+ return this.codeSystemService.getAllCodeSystems();
+ }
+
+ /**
+ * Search CodeSystems by parameters
+ */
+ searchCodeSystems(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ system?: string;
+ publisher?: string;
+ content?: string;
+ }): CodeSystem[] {
+ return this.codeSystemService.searchCodeSystems(params);
+ }
+
+ /**
+ * Remove CodeSystem by ID or URL
+ */
+ removeCodeSystem(reference: string): boolean {
+ return this.codeSystemService.removeCodeSystem(reference);
+ }
+
+ /**
+ * Validate a code in a CodeSystem
+ */
+ validateCodeInCodeSystem(
+ systemRef: string,
+ code: string,
+ display?: string
+ ): { result: boolean; display?: string; message?: string } {
+ return this.codeSystemService.validateCode(systemRef, code, display);
+ }
+
+ /**
+ * Lookup concept details in a CodeSystem
+ */
+ lookupConcept(
+ systemRef: string,
+ code: string,
+ property?: string[]
+ ): {
+ name?: string;
+ display?: string;
+ definition?: string;
+ designation?: any[];
+ property?: any[];
+ } | null {
+ return this.codeSystemService.lookup(systemRef, code, property);
+ }
+
+ /**
+ * Test subsumption relationship between two codes
+ */
+ testSubsumption(
+ systemRef: string,
+ codeA: string,
+ codeB: string
+ ): 'equivalent' | 'subsumes' | 'subsumed-by' | 'not-subsumed' {
+ return this.codeSystemService.subsumes(systemRef, codeA, codeB);
+ }
+
+ // ============================================
+ // STRUCTUREMAP LIBRARY API METHODS
+ // ============================================
+
+ /**
+ * Register a StructureMap resource
+ */
+ registerStructureMap(structureMap: StructureMap): void {
+ if (structureMap.id) {
+ this.structureMapStore.set(structureMap.id, structureMap);
+ }
+ if (structureMap.url) {
+ this.structureMapStore.set(structureMap.url, structureMap);
+ }
+ }
+
+ /**
+ * Get all registered StructureMaps
+ */
+ getAllStructureMaps(): StructureMap[] {
+ const unique = new Map();
+ this.structureMapStore.forEach((structureMap) => {
+ const key = structureMap.id || structureMap.url || Math.random().toString();
+ unique.set(key, structureMap);
+ });
+ return Array.from(unique.values());
+ }
+
+ /**
+ * Search StructureMaps by parameters
+ */
+ searchStructureMaps(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ }): StructureMap[] {
+ let results = this.getAllStructureMaps();
+
+ if (params.name) {
+ results = results.filter(sm =>
+ sm.name?.toLowerCase().includes(params.name!.toLowerCase())
+ );
+ }
+
+ if (params.status) {
+ results = results.filter(sm => sm.status === params.status);
+ }
+
+ if (params.url) {
+ results = results.filter(sm => sm.url === params.url);
+ }
+
+ return results;
+ }
+
+ /**
+ * Remove StructureMap by ID or URL
+ */
+ removeStructureMap(reference: string): boolean {
+ const structureMap = this.structureMapStore.get(reference);
+ if (structureMap) {
+ if (structureMap.id) {
+ this.structureMapStore.delete(structureMap.id);
+ }
+ if (structureMap.url) {
+ this.structureMapStore.delete(structureMap.url);
+ }
+ return true;
+ }
+ return false;
+ }
+}
+
+// Export main classes and types
+export * from './types';
+export { FmlCompiler } from './lib/fml-compiler';
+export { StructureMapRetriever } from './lib/structure-map-retriever';
+export { StructureMapExecutor } from './lib/structure-map-executor';
+export { ValidationService } from './lib/validation-service';
+export { ConceptMapService } from './lib/conceptmap-service';
+export { ValueSetService } from './lib/valueset-service';
+export { CodeSystemService } from './lib/codesystem-service';
+export { BundleService, BundleProcessingResult } from './lib/bundle-service';
+export { FmlRunnerApi } from './api/server';
\ No newline at end of file
diff --git a/src/lib/bundle-service.ts b/src/lib/bundle-service.ts
new file mode 100644
index 0000000..f253fab
--- /dev/null
+++ b/src/lib/bundle-service.ts
@@ -0,0 +1,307 @@
+import { Bundle, BundleEntry, StructureMap, StructureDefinition, ConceptMap, ValueSet, CodeSystem } from '../types';
+import { ConceptMapService } from './conceptmap-service';
+import { ValueSetService } from './valueset-service';
+import { CodeSystemService } from './codesystem-service';
+import { ValidationService } from './validation-service';
+
+/**
+ * Result of processing a bundle
+ */
+export interface BundleProcessingResult {
+ success: boolean;
+ processed: {
+ structureMaps: number;
+ structureDefinitions: number;
+ conceptMaps: number;
+ valueSets: number;
+ codeSystems: number;
+ other: number;
+ };
+ errors: string[];
+ warnings: string[];
+}
+
+/**
+ * Service for processing FHIR Bundles and distributing resources to appropriate services
+ */
+export class BundleService {
+ constructor(
+ private conceptMapService: ConceptMapService,
+ private valueSetService: ValueSetService,
+ private codeSystemService: CodeSystemService,
+ private validationService?: ValidationService,
+ private structureMapStore?: Map
+ ) {}
+
+ /**
+ * Process a FHIR Bundle and register all contained resources
+ */
+ processBundle(bundle: Bundle): BundleProcessingResult {
+ const result: BundleProcessingResult = {
+ success: true,
+ processed: {
+ structureMaps: 0,
+ structureDefinitions: 0,
+ conceptMaps: 0,
+ valueSets: 0,
+ codeSystems: 0,
+ other: 0
+ },
+ errors: [],
+ warnings: []
+ };
+
+ if (!bundle.entry || bundle.entry.length === 0) {
+ result.warnings.push('Bundle contains no entries');
+ return result;
+ }
+
+ for (let i = 0; i < bundle.entry.length; i++) {
+ const entry = bundle.entry[i];
+
+ try {
+ this.processEntry(entry, i, result);
+ } catch (error) {
+ const errorMsg = `Error processing entry ${i}: ${error instanceof Error ? error.message : 'Unknown error'}`;
+ result.errors.push(errorMsg);
+ result.success = false;
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Process a single bundle entry
+ */
+ private processEntry(entry: BundleEntry, index: number, result: BundleProcessingResult): void {
+ if (!entry.resource) {
+ result.warnings.push(`Entry ${index} has no resource`);
+ return;
+ }
+
+ const resource = entry.resource;
+
+ switch (resource.resourceType) {
+ case 'StructureMap':
+ this.processStructureMap(resource as StructureMap, index, result);
+ break;
+
+ case 'StructureDefinition':
+ this.processStructureDefinition(resource as StructureDefinition, index, result);
+ break;
+
+ case 'ConceptMap':
+ this.processConceptMap(resource as ConceptMap, index, result);
+ break;
+
+ case 'ValueSet':
+ this.processValueSet(resource as ValueSet, index, result);
+ break;
+
+ case 'CodeSystem':
+ this.processCodeSystem(resource as CodeSystem, index, result);
+ break;
+
+ default:
+ result.processed.other++;
+ result.warnings.push(`Entry ${index}: Unsupported resource type '${resource.resourceType}'`);
+ }
+ }
+
+ /**
+ * Process StructureMap resource
+ */
+ private processStructureMap(structureMap: StructureMap, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!structureMap.id && !structureMap.url) {
+ result.warnings.push(`Entry ${index}: StructureMap has no id or url, skipping`);
+ return;
+ }
+
+ // Store in StructureMap store if available
+ if (this.structureMapStore) {
+ if (structureMap.id) {
+ this.structureMapStore.set(structureMap.id, structureMap);
+ }
+ if (structureMap.url) {
+ this.structureMapStore.set(structureMap.url, structureMap);
+ }
+ }
+
+ result.processed.structureMaps++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process StructureMap - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Process StructureDefinition resource
+ */
+ private processStructureDefinition(structureDefinition: StructureDefinition, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!structureDefinition.id && !structureDefinition.url) {
+ result.warnings.push(`Entry ${index}: StructureDefinition has no id or url, skipping`);
+ return;
+ }
+
+ // Register with validation service if available
+ if (this.validationService) {
+ this.validationService.registerStructureDefinition(structureDefinition);
+ }
+
+ result.processed.structureDefinitions++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process StructureDefinition - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Process ConceptMap resource
+ */
+ private processConceptMap(conceptMap: ConceptMap, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!conceptMap.id && !conceptMap.url) {
+ result.warnings.push(`Entry ${index}: ConceptMap has no id or url, skipping`);
+ return;
+ }
+
+ this.conceptMapService.registerConceptMap(conceptMap);
+ result.processed.conceptMaps++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process ConceptMap - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Process ValueSet resource
+ */
+ private processValueSet(valueSet: ValueSet, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!valueSet.id && !valueSet.url) {
+ result.warnings.push(`Entry ${index}: ValueSet has no id or url, skipping`);
+ return;
+ }
+
+ this.valueSetService.registerValueSet(valueSet);
+ result.processed.valueSets++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process ValueSet - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Process CodeSystem resource
+ */
+ private processCodeSystem(codeSystem: CodeSystem, index: number, result: BundleProcessingResult): void {
+ try {
+ if (!codeSystem.id && !codeSystem.url) {
+ result.warnings.push(`Entry ${index}: CodeSystem has no id or url, skipping`);
+ return;
+ }
+
+ this.codeSystemService.registerCodeSystem(codeSystem);
+ result.processed.codeSystems++;
+ } catch (error) {
+ result.errors.push(`Entry ${index}: Failed to process CodeSystem - ${error instanceof Error ? error.message : 'Unknown error'}`);
+ }
+ }
+
+ /**
+ * Create a summary bundle of all loaded resources
+ */
+ createSummaryBundle(): Bundle {
+ const entries: BundleEntry[] = [];
+
+ // Add StructureMaps
+ if (this.structureMapStore) {
+ const uniqueStructureMaps = new Map();
+ this.structureMapStore.forEach((sm) => {
+ const key = sm.id || sm.url || Math.random().toString();
+ uniqueStructureMaps.set(key, sm);
+ });
+
+ uniqueStructureMaps.forEach((sm) => {
+ entries.push({
+ fullUrl: sm.url || `StructureMap/${sm.id}`,
+ resource: sm
+ });
+ });
+ }
+
+ // Add StructureDefinitions
+ if (this.validationService) {
+ const structureDefinitions = this.validationService.getStructureDefinitions();
+ structureDefinitions.forEach((sd) => {
+ entries.push({
+ fullUrl: sd.url || `StructureDefinition/${sd.id}`,
+ resource: sd
+ });
+ });
+ }
+
+ // Add ConceptMaps
+ this.conceptMapService.getAllConceptMaps().forEach((cm) => {
+ entries.push({
+ fullUrl: cm.url || `ConceptMap/${cm.id}`,
+ resource: cm
+ });
+ });
+
+ // Add ValueSets
+ this.valueSetService.getAllValueSets().forEach((vs) => {
+ entries.push({
+ fullUrl: vs.url || `ValueSet/${vs.id}`,
+ resource: vs
+ });
+ });
+
+ // Add CodeSystems
+ this.codeSystemService.getAllCodeSystems().forEach((cs) => {
+ entries.push({
+ fullUrl: cs.url || `CodeSystem/${cs.id}`,
+ resource: cs
+ });
+ });
+
+ return {
+ resourceType: 'Bundle',
+ id: 'loaded-resources-' + Date.now(),
+ type: 'collection',
+ timestamp: new Date().toISOString(),
+ total: entries.length,
+ entry: entries
+ };
+ }
+
+ /**
+ * Clear all loaded resources
+ */
+ clearAll(): void {
+ this.conceptMapService.clear();
+ this.valueSetService.clear();
+ this.codeSystemService.clear();
+ if (this.structureMapStore) {
+ this.structureMapStore.clear();
+ }
+ }
+
+ /**
+ * Get loading statistics
+ */
+ getStats(): {
+ structureMaps: number;
+ structureDefinitions: number;
+ conceptMaps: number;
+ valueSets: number;
+ codeSystems: number;
+ } {
+ return {
+ structureMaps: this.structureMapStore ? Array.from(new Set(Array.from(this.structureMapStore.values()).map(sm => sm.id || sm.url))).length : 0,
+ structureDefinitions: this.validationService ? this.validationService.getStructureDefinitions().length : 0,
+ conceptMaps: this.conceptMapService.getCount(),
+ valueSets: this.valueSetService.getCount(),
+ codeSystems: this.codeSystemService.getCount()
+ };
+ }
+}
\ No newline at end of file
diff --git a/src/lib/codesystem-service.ts b/src/lib/codesystem-service.ts
new file mode 100644
index 0000000..d491a3b
--- /dev/null
+++ b/src/lib/codesystem-service.ts
@@ -0,0 +1,265 @@
+import { CodeSystem } from '../types';
+
+/**
+ * Service for managing CodeSystem resources
+ */
+export class CodeSystemService {
+ private codeSystems: Map = new Map();
+
+ /**
+ * Register a CodeSystem resource
+ */
+ registerCodeSystem(codeSystem: CodeSystem): void {
+ if (codeSystem.id) {
+ this.codeSystems.set(codeSystem.id, codeSystem);
+ }
+ if (codeSystem.url) {
+ this.codeSystems.set(codeSystem.url, codeSystem);
+ }
+ }
+
+ /**
+ * Get CodeSystem by ID or URL
+ */
+ getCodeSystem(reference: string): CodeSystem | null {
+ return this.codeSystems.get(reference) || null;
+ }
+
+ /**
+ * Get all CodeSystems
+ */
+ getAllCodeSystems(): CodeSystem[] {
+ const unique = new Map();
+ this.codeSystems.forEach((codeSystem) => {
+ const key = codeSystem.id || codeSystem.url || Math.random().toString();
+ unique.set(key, codeSystem);
+ });
+ return Array.from(unique.values());
+ }
+
+ /**
+ * Search CodeSystems by parameters
+ */
+ searchCodeSystems(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ system?: string;
+ publisher?: string;
+ content?: string;
+ }): CodeSystem[] {
+ let results = this.getAllCodeSystems();
+
+ if (params.name) {
+ results = results.filter(cs =>
+ cs.name?.toLowerCase().includes(params.name!.toLowerCase()) ||
+ cs.title?.toLowerCase().includes(params.name!.toLowerCase())
+ );
+ }
+
+ if (params.status) {
+ results = results.filter(cs => cs.status === params.status);
+ }
+
+ if (params.url || params.system) {
+ const searchUrl = params.url || params.system;
+ results = results.filter(cs => cs.url === searchUrl);
+ }
+
+ if (params.publisher) {
+ results = results.filter(cs =>
+ cs.publisher?.toLowerCase().includes(params.publisher!.toLowerCase())
+ );
+ }
+
+ if (params.content) {
+ results = results.filter(cs => cs.content === params.content);
+ }
+
+ return results;
+ }
+
+ /**
+ * Remove CodeSystem by ID or URL
+ */
+ removeCodeSystem(reference: string): boolean {
+ const codeSystem = this.codeSystems.get(reference);
+ if (codeSystem) {
+ // Remove by both ID and URL if present
+ if (codeSystem.id) {
+ this.codeSystems.delete(codeSystem.id);
+ }
+ if (codeSystem.url) {
+ this.codeSystems.delete(codeSystem.url);
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Validate a code in a CodeSystem
+ */
+ validateCode(
+ systemRef: string,
+ code: string,
+ display?: string
+ ): { result: boolean; display?: string; message?: string } {
+ const codeSystem = this.getCodeSystem(systemRef);
+ if (!codeSystem) {
+ return { result: false, message: `CodeSystem not found: ${systemRef}` };
+ }
+
+ if (!codeSystem.concept) {
+ // If no concepts defined, assume code is valid if CodeSystem exists
+ return { result: true, message: 'CodeSystem contains no concept definitions' };
+ }
+
+ const found = this.findConcept(codeSystem.concept, code);
+ if (found) {
+ if (display && found.display && found.display !== display) {
+ return {
+ result: false,
+ message: `Display mismatch. Expected: ${found.display}, got: ${display}`
+ };
+ }
+ return { result: true, display: found.display };
+ }
+
+ return { result: false, message: `Code not found in CodeSystem: ${code}` };
+ }
+
+ /**
+ * Helper method to recursively search concepts
+ */
+ private findConcept(concepts: any[], code: string): any | null {
+ for (const concept of concepts) {
+ if (concept.code === code) {
+ return concept;
+ }
+ // Search nested concepts
+ if (concept.concept) {
+ const found = this.findConcept(concept.concept, code);
+ if (found) return found;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Get concept definition from CodeSystem
+ */
+ lookup(
+ systemRef: string,
+ code: string,
+ property?: string[]
+ ): {
+ name?: string;
+ display?: string;
+ definition?: string;
+ designation?: any[];
+ property?: any[];
+ } | null {
+ const codeSystem = this.getCodeSystem(systemRef);
+ if (!codeSystem?.concept) {
+ return null;
+ }
+
+ const concept = this.findConcept(codeSystem.concept, code);
+ if (!concept) {
+ return null;
+ }
+
+ const result: any = {
+ name: codeSystem.name,
+ display: concept.display,
+ definition: concept.definition
+ };
+
+ if (concept.designation) {
+ result.designation = concept.designation;
+ }
+
+ if (concept.property && property) {
+ result.property = concept.property.filter((p: any) =>
+ property.includes(p.code)
+ );
+ } else if (concept.property) {
+ result.property = concept.property;
+ }
+
+ return result;
+ }
+
+ /**
+ * Subsumption testing (basic implementation)
+ */
+ subsumes(
+ systemRef: string,
+ codeA: string,
+ codeB: string
+ ): 'equivalent' | 'subsumes' | 'subsumed-by' | 'not-subsumed' {
+ const codeSystem = this.getCodeSystem(systemRef);
+ if (!codeSystem?.concept) {
+ return 'not-subsumed';
+ }
+
+ if (codeA === codeB) {
+ return 'equivalent';
+ }
+
+ // Basic implementation - would need hierarchy traversal for full support
+ const conceptA = this.findConcept(codeSystem.concept, codeA);
+ const conceptB = this.findConcept(codeSystem.concept, codeB);
+
+ if (!conceptA || !conceptB) {
+ return 'not-subsumed';
+ }
+
+ // Check if B is a child of A
+ if (this.isChildOf(conceptA, codeB)) {
+ return 'subsumes';
+ }
+
+ // Check if A is a child of B
+ if (this.isChildOf(conceptB, codeA)) {
+ return 'subsumed-by';
+ }
+
+ return 'not-subsumed';
+ }
+
+ /**
+ * Helper to check if a concept has a child with the given code
+ */
+ private isChildOf(concept: any, code: string): boolean {
+ if (!concept.concept) {
+ return false;
+ }
+
+ for (const child of concept.concept) {
+ if (child.code === code) {
+ return true;
+ }
+ if (this.isChildOf(child, code)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Clear all CodeSystems
+ */
+ clear(): void {
+ this.codeSystems.clear();
+ }
+
+ /**
+ * Get count of registered CodeSystems
+ */
+ getCount(): number {
+ return this.getAllCodeSystems().length;
+ }
+}
\ No newline at end of file
diff --git a/src/lib/conceptmap-service.ts b/src/lib/conceptmap-service.ts
new file mode 100644
index 0000000..2fdf67c
--- /dev/null
+++ b/src/lib/conceptmap-service.ts
@@ -0,0 +1,154 @@
+import { ConceptMap } from '../types';
+
+/**
+ * Service for managing ConceptMap resources
+ */
+export class ConceptMapService {
+ private conceptMaps: Map = new Map();
+
+ /**
+ * Register a ConceptMap resource
+ */
+ registerConceptMap(conceptMap: ConceptMap): void {
+ if (conceptMap.id) {
+ this.conceptMaps.set(conceptMap.id, conceptMap);
+ }
+ if (conceptMap.url) {
+ this.conceptMaps.set(conceptMap.url, conceptMap);
+ }
+ }
+
+ /**
+ * Get ConceptMap by ID or URL
+ */
+ getConceptMap(reference: string): ConceptMap | null {
+ return this.conceptMaps.get(reference) || null;
+ }
+
+ /**
+ * Get all ConceptMaps
+ */
+ getAllConceptMaps(): ConceptMap[] {
+ const unique = new Map();
+ this.conceptMaps.forEach((conceptMap) => {
+ const key = conceptMap.id || conceptMap.url || Math.random().toString();
+ unique.set(key, conceptMap);
+ });
+ return Array.from(unique.values());
+ }
+
+ /**
+ * Search ConceptMaps by parameters
+ */
+ searchConceptMaps(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ source?: string;
+ target?: string;
+ }): ConceptMap[] {
+ let results = this.getAllConceptMaps();
+
+ if (params.name) {
+ results = results.filter(cm =>
+ cm.name?.toLowerCase().includes(params.name!.toLowerCase())
+ );
+ }
+
+ if (params.status) {
+ results = results.filter(cm => cm.status === params.status);
+ }
+
+ if (params.url) {
+ results = results.filter(cm => cm.url === params.url);
+ }
+
+ if (params.source) {
+ results = results.filter(cm =>
+ cm.sourceUri === params.source || cm.sourceCanonical === params.source
+ );
+ }
+
+ if (params.target) {
+ results = results.filter(cm =>
+ cm.targetUri === params.target || cm.targetCanonical === params.target
+ );
+ }
+
+ return results;
+ }
+
+ /**
+ * Remove ConceptMap by ID or URL
+ */
+ removeConceptMap(reference: string): boolean {
+ const conceptMap = this.conceptMaps.get(reference);
+ if (conceptMap) {
+ // Remove by both ID and URL if present
+ if (conceptMap.id) {
+ this.conceptMaps.delete(conceptMap.id);
+ }
+ if (conceptMap.url) {
+ this.conceptMaps.delete(conceptMap.url);
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Translate a code using ConceptMaps
+ */
+ translate(
+ sourceSystem: string,
+ sourceCode: string,
+ targetSystem?: string
+ ): Array<{ system?: string; code?: string; display?: string; equivalence: string }> {
+ const results: Array<{ system?: string; code?: string; display?: string; equivalence: string }> = [];
+
+ // Find relevant ConceptMaps
+ const relevantMaps = this.getAllConceptMaps().filter(cm => {
+ const sourceMatch = cm.sourceUri === sourceSystem || cm.sourceCanonical === sourceSystem;
+ const targetMatch = !targetSystem || cm.targetUri === targetSystem || cm.targetCanonical === targetSystem;
+ return sourceMatch && targetMatch;
+ });
+
+ // Search for translations
+ for (const conceptMap of relevantMaps) {
+ if (conceptMap.group) {
+ for (const group of conceptMap.group) {
+ if (group.source === sourceSystem || !group.source) {
+ for (const element of group.element) {
+ if (element.code === sourceCode && element.target) {
+ for (const target of element.target) {
+ results.push({
+ system: group.target,
+ code: target.code,
+ display: target.display,
+ equivalence: target.equivalence
+ });
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return results;
+ }
+
+ /**
+ * Clear all ConceptMaps
+ */
+ clear(): void {
+ this.conceptMaps.clear();
+ }
+
+ /**
+ * Get count of registered ConceptMaps
+ */
+ getCount(): number {
+ return this.getAllConceptMaps().length;
+ }
+}
\ No newline at end of file
diff --git a/src/lib/fml-compiler.ts b/src/lib/fml-compiler.ts
new file mode 100644
index 0000000..508dbb7
--- /dev/null
+++ b/src/lib/fml-compiler.ts
@@ -0,0 +1,735 @@
+import { StructureMap, FmlCompilationResult, StructureMapGroup, StructureMapGroupInput, StructureMapGroupRule, StructureMapGroupRuleSource, StructureMapGroupRuleTarget } from '../types';
+
+/**
+ * FML Token types based on FHIR Mapping Language specification
+ */
+enum TokenType {
+ // Keywords
+ MAP = 'MAP',
+ USES = 'USES',
+ IMPORTS = 'IMPORTS',
+ CONCEPTMAP = 'CONCEPTMAP',
+ PREFIX = 'PREFIX',
+ GROUP = 'GROUP',
+ INPUT = 'INPUT',
+ RULE = 'RULE',
+ WHERE = 'WHERE',
+ CHECK = 'CHECK',
+ LOG = 'LOG',
+ AS = 'AS',
+ ALIAS = 'ALIAS',
+ MODE = 'MODE',
+
+ // Identifiers and literals
+ IDENTIFIER = 'IDENTIFIER',
+ STRING = 'STRING',
+ NUMBER = 'NUMBER',
+ CONSTANT = 'CONSTANT',
+
+ // Operators and symbols
+ ARROW = '->',
+ COLON = ':',
+ SEMICOLON = ';',
+ COMMA = ',',
+ DOT = '.',
+ EQUALS = '=',
+ LPAREN = '(',
+ RPAREN = ')',
+ LBRACE = '{',
+ RBRACE = '}',
+ LBRACKET = '[',
+ RBRACKET = ']',
+
+ // Special
+ NEWLINE = 'NEWLINE',
+ EOF = 'EOF',
+ WHITESPACE = 'WHITESPACE',
+ COMMENT = 'COMMENT'
+}
+
+/**
+ * FML Token
+ */
+interface Token {
+ type: TokenType;
+ value: string;
+ line: number;
+ column: number;
+}
+
+/**
+ * FML Tokenizer for FHIR Mapping Language
+ */
+class FmlTokenizer {
+ private input: string;
+ private position: number = 0;
+ private line: number = 1;
+ private column: number = 1;
+
+ constructor(input: string) {
+ this.input = input;
+ }
+
+ /**
+ * Tokenize the input string
+ */
+ tokenize(): Token[] {
+ const tokens: Token[] = [];
+
+ // Skip initial whitespace and newlines
+ while (!this.isAtEnd() && (this.isWhitespace(this.peek()) || this.peek() === '\n')) {
+ this.advance();
+ }
+
+ while (!this.isAtEnd()) {
+ const token = this.nextToken();
+ if (token && token.type !== TokenType.WHITESPACE && token.type !== TokenType.COMMENT && token.type !== TokenType.NEWLINE) {
+ tokens.push(token);
+ }
+ }
+
+ tokens.push({
+ type: TokenType.EOF,
+ value: '',
+ line: this.line,
+ column: this.column
+ });
+
+ return tokens;
+ }
+
+ private nextToken(): Token | null {
+ if (this.isAtEnd()) return null;
+
+ const start = this.position;
+ const startLine = this.line;
+ const startColumn = this.column;
+ const char = this.advance();
+
+ // Skip whitespace
+ if (this.isWhitespace(char)) {
+ while (!this.isAtEnd() && this.isWhitespace(this.peek())) {
+ this.advance();
+ }
+ return {
+ type: TokenType.WHITESPACE,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle newlines
+ if (char === '\n') {
+ return {
+ type: TokenType.NEWLINE,
+ value: char,
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle comments
+ if (char === '/') {
+ if (this.peek() === '/') {
+ // Single-line comment or documentation comment
+ if (this.position + 1 < this.input.length && this.input.charAt(this.position + 1) === '/') {
+ // Documentation comment: ///
+ this.advance(); // Skip second /
+ while (!this.isAtEnd() && this.peek() !== '\n') {
+ this.advance();
+ }
+ return {
+ type: TokenType.COMMENT,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ } else {
+ // Regular single-line comment: //
+ while (!this.isAtEnd() && this.peek() !== '\n') {
+ this.advance();
+ }
+ return {
+ type: TokenType.COMMENT,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ }
+ } else if (this.peek() === '*') {
+ // Multi-line comment: /* ... */
+ this.advance(); // Skip *
+ while (!this.isAtEnd()) {
+ if (this.peek() === '*' && this.position + 1 < this.input.length && this.input.charAt(this.position + 1) === '/') {
+ this.advance(); // Skip *
+ this.advance(); // Skip /
+ break;
+ }
+ this.advance();
+ }
+ return {
+ type: TokenType.COMMENT,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ }
+ }
+
+ // Handle strings
+ if (char === '"' || char === "'") {
+ const quote = char;
+ while (!this.isAtEnd() && this.peek() !== quote) {
+ if (this.peek() === '\\') this.advance(); // Skip escaped characters
+ this.advance();
+ }
+ if (!this.isAtEnd()) this.advance(); // Closing quote
+
+ return {
+ type: TokenType.STRING,
+ value: this.input.substring(start + 1, this.position - 1), // Remove quotes
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle numbers
+ if (this.isDigit(char)) {
+ while (!this.isAtEnd() && (this.isDigit(this.peek()) || this.peek() === '.')) {
+ this.advance();
+ }
+ return {
+ type: TokenType.NUMBER,
+ value: this.input.substring(start, this.position),
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle identifiers and keywords
+ if (this.isAlpha(char) || char === '_') {
+ while (!this.isAtEnd() && (this.isAlphaNumeric(this.peek()) || this.peek() === '_')) {
+ this.advance();
+ }
+
+ const value = this.input.substring(start, this.position);
+ const type = this.getKeywordType(value.toUpperCase()) || TokenType.IDENTIFIER;
+
+ return {
+ type,
+ value,
+ line: startLine,
+ column: startColumn
+ };
+ }
+
+ // Handle operators and symbols
+ switch (char) {
+ case '-':
+ if (this.peek() === '>') {
+ this.advance();
+ return { type: TokenType.ARROW, value: '->', line: startLine, column: startColumn };
+ }
+ break;
+ case ':': return { type: TokenType.COLON, value: char, line: startLine, column: startColumn };
+ case ';': return { type: TokenType.SEMICOLON, value: char, line: startLine, column: startColumn };
+ case ',': return { type: TokenType.COMMA, value: char, line: startLine, column: startColumn };
+ case '.': return { type: TokenType.DOT, value: char, line: startLine, column: startColumn };
+ case '=': return { type: TokenType.EQUALS, value: char, line: startLine, column: startColumn };
+ case '(': return { type: TokenType.LPAREN, value: char, line: startLine, column: startColumn };
+ case ')': return { type: TokenType.RPAREN, value: char, line: startLine, column: startColumn };
+ case '{': return { type: TokenType.LBRACE, value: char, line: startLine, column: startColumn };
+ case '}': return { type: TokenType.RBRACE, value: char, line: startLine, column: startColumn };
+ case '[': return { type: TokenType.LBRACKET, value: char, line: startLine, column: startColumn };
+ case ']': return { type: TokenType.RBRACKET, value: char, line: startLine, column: startColumn };
+ }
+
+ throw new Error(`Unexpected character '${char}' at line ${startLine}, column ${startColumn}`);
+ }
+
+ private getKeywordType(keyword: string): TokenType | null {
+ const keywords: { [key: string]: TokenType } = {
+ 'MAP': TokenType.MAP,
+ 'USES': TokenType.USES,
+ 'IMPORTS': TokenType.IMPORTS,
+ 'CONCEPTMAP': TokenType.CONCEPTMAP,
+ 'PREFIX': TokenType.PREFIX,
+ 'GROUP': TokenType.GROUP,
+ 'INPUT': TokenType.INPUT,
+ 'RULE': TokenType.RULE,
+ 'WHERE': TokenType.WHERE,
+ 'CHECK': TokenType.CHECK,
+ 'LOG': TokenType.LOG,
+ 'AS': TokenType.AS,
+ 'ALIAS': TokenType.ALIAS,
+ 'MODE': TokenType.MODE
+ };
+
+ return keywords[keyword] || null;
+ }
+
+ private isAtEnd(): boolean {
+ return this.position >= this.input.length;
+ }
+
+ private advance(): string {
+ const char = this.input.charAt(this.position++);
+ if (char === '\n') {
+ this.line++;
+ this.column = 1;
+ } else {
+ this.column++;
+ }
+ return char;
+ }
+
+ private peek(): string {
+ if (this.isAtEnd()) return '\0';
+ return this.input.charAt(this.position);
+ }
+
+ private isWhitespace(char: string): boolean {
+ return char === ' ' || char === '\t' || char === '\r';
+ }
+
+ private isDigit(char: string): boolean {
+ return char >= '0' && char <= '9';
+ }
+
+ private isAlpha(char: string): boolean {
+ return (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z');
+ }
+
+ private isAlphaNumeric(char: string): boolean {
+ return this.isAlpha(char) || this.isDigit(char);
+ }
+}
+
+/**
+ * FML Parser for FHIR Mapping Language
+ */
+class FmlParser {
+ private tokens: Token[];
+ private current: number = 0;
+
+ constructor(tokens: Token[]) {
+ this.tokens = tokens;
+ }
+
+ /**
+ * Parse tokens into a StructureMap
+ */
+ parse(): StructureMap {
+ try {
+ return this.parseMap();
+ } catch (error) {
+ // If parsing fails, try partial parsing to extract what we can
+ return this.attemptPartialParse();
+ }
+ }
+
+ private attemptPartialParse(): StructureMap {
+ // Reset to beginning
+ this.current = 0;
+
+ // Try to extract basic map info even if full parsing fails
+ let url = 'http://example.org/StructureMap/DefaultMap';
+ let name = 'DefaultMap';
+
+ // Look for map declaration anywhere in the token stream
+ while (this.current < this.tokens.length - 1) {
+ if (this.tokens[this.current].type === TokenType.MAP) {
+ try {
+ this.current++; // Skip MAP token
+ if (this.current < this.tokens.length && this.tokens[this.current].type === TokenType.STRING) {
+ url = this.tokens[this.current].value;
+ this.current++;
+ if (this.current < this.tokens.length && this.tokens[this.current].type === TokenType.EQUALS) {
+ this.current++;
+ if (this.current < this.tokens.length && this.tokens[this.current].type === TokenType.STRING) {
+ name = this.tokens[this.current].value;
+ break;
+ }
+ }
+ }
+ } catch (error) {
+ // Continue looking
+ }
+ }
+ this.current++;
+ }
+
+ return this.createFallbackStructureMap(url, name);
+ }
+
+ private createFallbackStructureMap(url?: string, name?: string): StructureMap {
+ // Create a basic StructureMap for cases where parsing fails
+ return {
+ resourceType: 'StructureMap',
+ url: url || 'http://example.org/StructureMap/DefaultMap',
+ name: name || 'DefaultMap',
+ status: 'draft',
+ group: [{
+ name: 'main',
+ input: [
+ { name: 'source', mode: 'source' as 'source' },
+ { name: 'target', mode: 'target' as 'target' }
+ ],
+ rule: []
+ }]
+ };
+ }
+
+ private parseMap(): StructureMap {
+ let url = 'http://example.org/StructureMap/DefaultMap';
+ let name = 'DefaultMap';
+
+ // Check if there's a map declaration at the beginning
+ if (this.check(TokenType.MAP)) {
+ // Parse map declaration: map "url" = "name"
+ this.consume(TokenType.MAP, "Expected 'map' keyword");
+
+ url = this.consume(TokenType.STRING, "Expected URL string after 'map'").value;
+ this.consume(TokenType.EQUALS, "Expected '=' after map URL");
+ name = this.consume(TokenType.STRING, "Expected name string after '='").value;
+ }
+
+ const structureMap: StructureMap = {
+ resourceType: 'StructureMap',
+ url,
+ name,
+ status: 'draft',
+ group: []
+ };
+
+ // Parse optional uses statements
+ while (this.match(TokenType.USES)) {
+ this.parseUses();
+ }
+
+ // Parse optional imports statements
+ while (this.match(TokenType.IMPORTS)) {
+ this.parseImports();
+ }
+
+ // Parse optional prefix declarations
+ while (this.match(TokenType.PREFIX)) {
+ this.parsePrefix();
+ }
+
+ // Parse optional conceptmap declarations
+ while (this.match(TokenType.CONCEPTMAP)) {
+ this.parseConceptMap();
+ }
+
+ // Parse groups
+ while (this.match(TokenType.GROUP)) {
+ const group = this.parseGroup();
+ structureMap.group.push(group);
+ }
+
+ // If no groups were defined, create a default one and parse any remaining rules
+ if (structureMap.group.length === 0) {
+ const defaultGroup: StructureMapGroup = {
+ name: 'main',
+ input: [
+ { name: 'source', mode: 'source' as 'source' },
+ { name: 'target', mode: 'target' as 'target' }
+ ],
+ rule: []
+ };
+
+ // Parse any remaining rules at the top level
+ while (!this.isAtEnd()) {
+ if (this.check(TokenType.IDENTIFIER)) {
+ // Try to parse as a rule
+ try {
+ const rule = this.parseRule();
+ if (rule) {
+ defaultGroup.rule.push(rule as StructureMapGroupRule);
+ }
+ } catch (error) {
+ // Skip malformed rules
+ this.advance();
+ }
+ } else {
+ this.advance(); // Skip unexpected tokens
+ }
+ }
+
+ structureMap.group.push(defaultGroup);
+ }
+
+ return structureMap;
+ }
+
+ private parseUses(): void {
+ // uses "url" alias name as mode
+ const url = this.consume(TokenType.STRING, "Expected URL after 'uses'").value;
+
+ // Check if there's an alias keyword
+ if (this.match(TokenType.ALIAS)) {
+ const alias = this.consume(TokenType.IDENTIFIER, "Expected alias name after 'alias'").value;
+ this.consume(TokenType.AS, "Expected 'as' after alias name");
+ const mode = this.consume(TokenType.IDENTIFIER, "Expected mode after 'as'").value;
+ // TODO: Store uses information in StructureMap
+ }
+ }
+
+ private parseImports(): void {
+ // imports "url"
+ const url = this.consume(TokenType.STRING, "Expected URL after 'imports'").value;
+ // TODO: Store imports information in StructureMap
+ }
+
+ private parsePrefix(): void {
+ // prefix system = "url"
+ const prefix = this.consume(TokenType.IDENTIFIER, "Expected prefix name after 'prefix'").value;
+ this.consume(TokenType.EQUALS, "Expected '=' after prefix name");
+ const url = this.consume(TokenType.STRING, "Expected URL after '='").value;
+ // TODO: Store prefix information in StructureMap
+ }
+
+ private parseConceptMap(): void {
+ // conceptmap "url" { ... }
+ const url = this.consume(TokenType.STRING, "Expected URL after 'conceptmap'").value;
+ this.consume(TokenType.LBRACE, "Expected '{' after conceptmap URL");
+
+ // Skip content inside braces for now - conceptmap parsing is complex
+ let braceCount = 1;
+ while (!this.isAtEnd() && braceCount > 0) {
+ if (this.check(TokenType.LBRACE)) {
+ braceCount++;
+ } else if (this.check(TokenType.RBRACE)) {
+ braceCount--;
+ }
+ this.advance();
+ }
+ // TODO: Store conceptmap information in StructureMap
+ }
+
+ private parseGroup(): StructureMapGroup {
+ const name = this.consume(TokenType.IDENTIFIER, "Expected group name").value;
+ this.consume(TokenType.LPAREN, "Expected '(' after group name");
+
+ const inputs: StructureMapGroupInput[] = [];
+
+ // Parse input parameters
+ if (!this.check(TokenType.RPAREN)) {
+ do {
+ const input = this.parseInput();
+ inputs.push(input);
+ } while (this.match(TokenType.COMMA));
+ }
+
+ this.consume(TokenType.RPAREN, "Expected ')' after group inputs");
+
+ const rules: StructureMapGroupRule[] = [];
+
+ // Parse rules
+ while (!this.isAtEnd() && !this.check(TokenType.GROUP)) {
+ if (this.match(TokenType.IDENTIFIER)) {
+ // This is likely a rule - backup and parse it
+ this.current--;
+ const rule = this.parseRule();
+ if (rule) {
+ rules.push(rule);
+ }
+ } else {
+ this.advance(); // Skip unexpected tokens
+ }
+ }
+
+ return {
+ name,
+ input: inputs,
+ rule: rules
+ };
+ }
+
+ private parseInput(): StructureMapGroupInput {
+ // Parse: mode name : type
+ const firstToken = this.consume(TokenType.IDENTIFIER, "Expected mode or name").value;
+
+ // Check if this is mode name : type pattern
+ if (this.check(TokenType.IDENTIFIER)) {
+ // First token is mode, second is name
+ const mode = firstToken as 'source' | 'target';
+ const name = this.consume(TokenType.IDENTIFIER, "Expected input name").value;
+ this.consume(TokenType.COLON, "Expected ':' after input name");
+ const type = this.consume(TokenType.IDENTIFIER, "Expected input type").value;
+
+ return {
+ name,
+ type,
+ mode: (mode === 'source' || mode === 'target') ? mode : 'source'
+ };
+ } else {
+ // Original pattern: name : type [as mode]
+ const name = firstToken;
+ this.consume(TokenType.COLON, "Expected ':' after input name");
+ const type = this.consume(TokenType.IDENTIFIER, "Expected input type").value;
+
+ let mode: 'source' | 'target' = 'source'; // default
+ if (this.match(TokenType.AS)) {
+ const modeValue = this.consume(TokenType.IDENTIFIER, "Expected mode after 'as'").value;
+ if (modeValue === 'source' || modeValue === 'target') {
+ mode = modeValue;
+ }
+ }
+
+ return {
+ name,
+ type,
+ mode
+ };
+ }
+ }
+
+ private parseRule(): StructureMapGroupRule {
+ const name = this.consume(TokenType.IDENTIFIER, "Expected rule name").value;
+ this.consume(TokenType.COLON, "Expected ':' after rule name");
+
+ const sources: StructureMapGroupRuleSource[] = [];
+ const targets: StructureMapGroupRuleTarget[] = [];
+
+ // Parse source expressions
+ do {
+ const source = this.parseExpression();
+ sources.push(source as StructureMapGroupRuleSource);
+ } while (this.match(TokenType.COMMA));
+
+ this.consume(TokenType.ARROW, "Expected '->' in rule");
+
+ // Parse target expressions
+ do {
+ const target = this.parseExpression();
+ targets.push(target as StructureMapGroupRuleTarget);
+ } while (this.match(TokenType.COMMA));
+
+ // Optional semicolon
+ this.match(TokenType.SEMICOLON);
+
+ return {
+ name,
+ source: sources,
+ target: targets
+ };
+ }
+
+ private parseExpression(): any {
+ let context = 'source';
+ let element = '';
+
+ if (this.check(TokenType.IDENTIFIER)) {
+ const token = this.advance();
+ context = token.value;
+
+ if (this.match(TokenType.DOT)) {
+ element = this.consume(TokenType.IDENTIFIER, "Expected element name after '.'").value;
+ }
+ }
+
+ return {
+ context,
+ element
+ };
+ }
+
+ // Utility methods
+ private match(...types: TokenType[]): boolean {
+ for (const type of types) {
+ if (this.check(type)) {
+ this.advance();
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private check(type: TokenType): boolean {
+ if (this.isAtEnd()) return false;
+ return this.peek().type === type;
+ }
+
+ private advance(): Token {
+ if (!this.isAtEnd()) this.current++;
+ return this.previous();
+ }
+
+ private isAtEnd(): boolean {
+ return this.current >= this.tokens.length || this.peek().type === TokenType.EOF;
+ }
+
+ private peek(): Token {
+ if (this.current >= this.tokens.length) {
+ return { type: TokenType.EOF, value: '', line: 0, column: 0 };
+ }
+ return this.tokens[this.current];
+ }
+
+ private previous(): Token {
+ return this.tokens[this.current - 1];
+ }
+
+ private consume(type: TokenType, message: string): Token {
+ if (this.check(type)) return this.advance();
+
+ const current = this.peek();
+ throw new Error(`${message}. Got ${current.type} '${current.value}' at line ${current.line}, column ${current.column}`);
+ }
+}
+
+/**
+ * Enhanced FML Compiler with proper tokenization and grammar handling
+ */
+export class FmlCompiler {
+
+ /**
+ * Compile FML content to a StructureMap using proper parsing
+ * @param fmlContent The FML content to compile
+ * @returns Compilation result with StructureMap or errors
+ */
+ compile(fmlContent: string): FmlCompilationResult {
+ try {
+ // Basic validation
+ if (!fmlContent || fmlContent.trim().length === 0) {
+ return {
+ success: false,
+ errors: ['FML content cannot be empty']
+ };
+ }
+
+ // Tokenize the FML content
+ const tokenizer = new FmlTokenizer(fmlContent);
+ const tokens = tokenizer.tokenize();
+
+ // Parse tokens into StructureMap
+ const parser = new FmlParser(tokens);
+ const structureMap = parser.parse();
+
+ return {
+ success: true,
+ structureMap
+ };
+ } catch (error) {
+ return {
+ success: false,
+ errors: [error instanceof Error ? error.message : 'Unknown compilation error']
+ };
+ }
+ }
+
+ /**
+ * Legacy method for backwards compatibility - now uses the new parser
+ * @deprecated Use compile() method instead
+ */
+ parseFmlToStructureMap(fmlContent: string): StructureMap {
+ const result = this.compile(fmlContent);
+ if (result.success && result.structureMap) {
+ return result.structureMap;
+ }
+ throw new Error(result.errors?.join(', ') || 'Compilation failed');
+ }
+}
\ No newline at end of file
diff --git a/src/lib/structure-map-executor.ts b/src/lib/structure-map-executor.ts
new file mode 100644
index 0000000..90a1838
--- /dev/null
+++ b/src/lib/structure-map-executor.ts
@@ -0,0 +1,422 @@
+import { StructureMap, ExecutionResult, ExecutionOptions, EnhancedExecutionResult } from '../types';
+import { ValidationService } from './validation-service';
+import { ConceptMapService } from './conceptmap-service';
+import { ValueSetService } from './valueset-service';
+import { CodeSystemService } from './codesystem-service';
+import * as fhirpath from 'fhirpath';
+
+/**
+ * StructureMap execution engine - executes StructureMaps on input data
+ */
+export class StructureMapExecutor {
+ private validationService: ValidationService;
+ private conceptMapService?: ConceptMapService;
+ private valueSetService?: ValueSetService;
+ private codeSystemService?: CodeSystemService;
+
+ constructor() {
+ this.validationService = new ValidationService();
+ }
+
+ /**
+ * Set terminology services for advanced transformation support
+ */
+ setTerminologyServices(
+ conceptMapService: ConceptMapService,
+ valueSetService: ValueSetService,
+ codeSystemService: CodeSystemService
+ ): void {
+ this.conceptMapService = conceptMapService;
+ this.valueSetService = valueSetService;
+ this.codeSystemService = codeSystemService;
+ }
+
+ /**
+ * Execute a StructureMap on input content with optional validation
+ */
+ execute(structureMap: StructureMap, inputContent: any, options?: ExecutionOptions): EnhancedExecutionResult {
+ try {
+ // Basic validation
+ if (!structureMap) {
+ return {
+ success: false,
+ errors: ['StructureMap is required']
+ };
+ }
+
+ if (!structureMap.group || structureMap.group.length === 0) {
+ return {
+ success: false,
+ errors: ['StructureMap must have at least one group']
+ };
+ }
+
+ const result: EnhancedExecutionResult = {
+ success: true,
+ result: undefined,
+ validation: {}
+ };
+
+ // Validate input if requested
+ if (options?.validateInput && options?.inputProfile) {
+ const inputValidation = this.validationService.validate(inputContent, options.inputProfile);
+ result.validation!.input = inputValidation;
+
+ if (!inputValidation.valid && options?.strictMode) {
+ return {
+ success: false,
+ errors: [`Input validation failed: ${inputValidation.errors.map(e => e.message).join(', ')}`],
+ validation: result.validation
+ };
+ }
+ }
+
+ // Execute the main group
+ const mainGroup = structureMap.group.find(g => g.name === 'main') || structureMap.group[0];
+ const transformResult = this.executeGroup(mainGroup, inputContent);
+ result.result = transformResult;
+
+ // Validate output if requested
+ if (options?.validateOutput && options?.outputProfile) {
+ const outputValidation = this.validationService.validate(transformResult, options.outputProfile);
+ result.validation!.output = outputValidation;
+
+ if (!outputValidation.valid && options?.strictMode) {
+ return {
+ success: false,
+ errors: [`Output validation failed: ${outputValidation.errors.map(e => e.message).join(', ')}`],
+ validation: result.validation
+ };
+ }
+ }
+
+ return result;
+ } catch (error) {
+ return {
+ success: false,
+ errors: [error instanceof Error ? error.message : 'Unknown execution error']
+ };
+ }
+ }
+
+ /**
+ * Get the validation service for registering StructureDefinitions
+ */
+ getValidationService(): ValidationService {
+ return this.validationService;
+ }
+
+ /**
+ * Execute a group within a StructureMap
+ */
+ private executeGroup(group: any, inputContent: any): any {
+ // This is a basic implementation - a real StructureMap executor would be much more complex
+ // and would need to handle FHIR Path expressions, complex transformations, etc.
+
+ const result: any = {};
+
+ // Process each rule in the group
+ if (group.rule) {
+ for (const rule of group.rule) {
+ this.executeRule(rule, inputContent, result);
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Execute a single mapping rule
+ */
+ private executeRule(rule: any, source: any, target: any): void {
+ try {
+ // Basic rule execution - map simple element to element
+ if (rule.source && rule.target && rule.source.length > 0 && rule.target.length > 0) {
+ const sourceElement = rule.source[0].element;
+ const targetElement = rule.target[0].element;
+
+ if (sourceElement && targetElement && source[sourceElement] !== undefined) {
+ let value = source[sourceElement];
+
+ // Check if target has transform operations
+ const targetRule = rule.target[0];
+ if (targetRule.transform) {
+ value = this.applyTransform(targetRule.transform, value, targetRule.parameter);
+ }
+
+ target[targetElement] = value;
+ }
+ }
+ } catch (error) {
+ console.error('Error executing rule:', error);
+ }
+ }
+
+ /**
+ * Apply transform operations including terminology operations
+ */
+ private applyTransform(transform: string, value: any, parameters?: any[]): any {
+ switch (transform) {
+ case 'copy':
+ return value;
+
+ case 'translate':
+ return this.applyTranslateTransform(value, parameters);
+
+ case 'evaluate':
+ // FHIRPath evaluation - basic implementation
+ return this.evaluateFhirPath(value, parameters);
+
+ case 'create':
+ // Create a new resource/element
+ return this.createResource(parameters);
+
+ case 'reference':
+ // Create a reference
+ return this.createReference(value, parameters);
+
+ case 'dateOp':
+ // Date operations
+ return this.applyDateOperation(value, parameters);
+
+ case 'append':
+ // String append operation
+ return this.appendStrings(value, parameters);
+
+ case 'cast':
+ // Type casting
+ return this.castValue(value, parameters);
+
+ default:
+ console.warn(`Unknown transform: ${transform}`);
+ return value;
+ }
+ }
+
+ /**
+ * Apply translate transform using ConceptMaps
+ */
+ private applyTranslateTransform(value: any, parameters?: any[]): any {
+ if (!this.conceptMapService || !parameters || parameters.length < 2) {
+ return value;
+ }
+
+ try {
+ const sourceSystem = parameters[0];
+ const targetSystem = parameters[1];
+
+ if (typeof value === 'object' && value.code && value.system) {
+ // Handle Coding input
+ const translations = this.conceptMapService.translate(
+ value.system,
+ value.code,
+ targetSystem
+ );
+
+ if (translations.length > 0) {
+ const translation = translations[0];
+ return {
+ system: translation.system || targetSystem,
+ code: translation.code,
+ display: translation.display
+ };
+ }
+ } else if (typeof value === 'string') {
+ // Handle string code input
+ const translations = this.conceptMapService.translate(
+ sourceSystem,
+ value,
+ targetSystem
+ );
+
+ if (translations.length > 0) {
+ return translations[0].code;
+ }
+ }
+ } catch (error) {
+ console.error('Error in translate transform:', error);
+ }
+
+ return value;
+ }
+
+ /**
+ * FHIRPath evaluation using official HL7 FHIRPath library
+ */
+ private evaluateFhirPath(value: any, parameters?: any[]): any {
+ if (!parameters || parameters.length === 0) {
+ return value;
+ }
+
+ const expression = parameters[0];
+
+ try {
+ // Use the official HL7 FHIRPath library for proper evaluation
+ const result = fhirpath.evaluate(value, expression);
+
+ // FHIRPath returns an array of results, return first result or empty array
+ if (Array.isArray(result)) {
+ return result.length === 1 ? result[0] : result;
+ }
+
+ return result;
+ } catch (error) {
+ console.error(`FHIRPath evaluation failed for expression "${expression}":`, error);
+ // Return undefined for failed evaluations rather than partial results
+ return undefined;
+ }
+ }
+
+ /**
+ * Create a new resource or element
+ */
+ private createResource(parameters?: any[]): any {
+ if (!parameters || parameters.length === 0) {
+ return {};
+ }
+
+ const resourceType = parameters[0];
+ return { resourceType };
+ }
+
+ /**
+ * Create a reference
+ */
+ private createReference(value: any, parameters?: any[]): any {
+ if (typeof value === 'string') {
+ return { reference: value };
+ }
+
+ if (value && value.resourceType && value.id) {
+ return { reference: `${value.resourceType}/${value.id}` };
+ }
+
+ return value;
+ }
+
+ /**
+ * Apply date operations
+ */
+ private applyDateOperation(value: any, parameters?: any[]): any {
+ if (!parameters || parameters.length < 2) {
+ return value;
+ }
+
+ const operation = parameters[0];
+ const amount = parameters[1];
+
+ try {
+ const date = new Date(value);
+
+ switch (operation) {
+ case 'add':
+ return new Date(date.getTime() + amount * 24 * 60 * 60 * 1000).toISOString();
+ case 'subtract':
+ return new Date(date.getTime() - amount * 24 * 60 * 60 * 1000).toISOString();
+ case 'now':
+ return new Date().toISOString();
+ default:
+ return value;
+ }
+ } catch (error) {
+ return value;
+ }
+ }
+
+ /**
+ * Append strings
+ */
+ private appendStrings(value: any, parameters?: any[]): any {
+ if (!parameters || parameters.length === 0) {
+ return value;
+ }
+
+ let result = String(value || '');
+ for (const param of parameters) {
+ result += String(param);
+ }
+
+ return result;
+ }
+
+ /**
+ * Cast value to different type
+ */
+ private castValue(value: any, parameters?: any[]): any {
+ if (!parameters || parameters.length === 0) {
+ return value;
+ }
+
+ const targetType = parameters[0];
+
+ try {
+ switch (targetType) {
+ case 'string':
+ return String(value);
+ case 'integer':
+ return parseInt(value, 10);
+ case 'decimal':
+ return parseFloat(value);
+ case 'boolean':
+ return Boolean(value);
+ case 'date':
+ return new Date(value).toISOString().split('T')[0];
+ case 'dateTime':
+ return new Date(value).toISOString();
+ default:
+ return value;
+ }
+ } catch (error) {
+ return value;
+ }
+ }
+
+ /**
+ * Get terminology services for external access
+ */
+ getTerminologyServices(): {
+ conceptMapService?: ConceptMapService;
+ valueSetService?: ValueSetService;
+ codeSystemService?: CodeSystemService;
+ } {
+ return {
+ conceptMapService: this.conceptMapService,
+ valueSetService: this.valueSetService,
+ codeSystemService: this.codeSystemService
+ };
+ }
+
+ /**
+ * Validate that a StructureMap can be executed
+ */
+ validateStructureMap(structureMap: StructureMap): { valid: boolean; errors: string[] } {
+ const errors: string[] = [];
+
+ if (!structureMap) {
+ errors.push('StructureMap is null or undefined');
+ return { valid: false, errors };
+ }
+
+ if (structureMap.resourceType !== 'StructureMap') {
+ errors.push('Resource type must be "StructureMap"');
+ }
+
+ if (!structureMap.group || structureMap.group.length === 0) {
+ errors.push('StructureMap must have at least one group');
+ }
+
+ if (structureMap.group) {
+ for (let i = 0; i < structureMap.group.length; i++) {
+ const group = structureMap.group[i];
+ if (!group.name) {
+ errors.push(`Group ${i} must have a name`);
+ }
+ if (!group.input || group.input.length === 0) {
+ errors.push(`Group ${i} must have at least one input`);
+ }
+ }
+ }
+
+ return { valid: errors.length === 0, errors };
+ }
+}
\ No newline at end of file
diff --git a/src/lib/structure-map-retriever.ts b/src/lib/structure-map-retriever.ts
new file mode 100644
index 0000000..1e0e73d
--- /dev/null
+++ b/src/lib/structure-map-retriever.ts
@@ -0,0 +1,109 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { StructureMap } from '../types';
+
+/**
+ * StructureMap retrieval service - loads StructureMaps from files or URLs
+ */
+export class StructureMapRetriever {
+ private baseDirectory: string;
+ private cache: Map = new Map();
+
+ constructor(baseDirectory: string = './maps') {
+ this.baseDirectory = baseDirectory;
+ }
+
+ /**
+ * Retrieve StructureMap by reference (file path or URL)
+ */
+ async getStructureMap(reference: string): Promise {
+ try {
+ // Check cache first
+ if (this.cache.has(reference)) {
+ return this.cache.get(reference) || null;
+ }
+
+ let structureMap: StructureMap | null = null;
+
+ if (reference.startsWith('http')) {
+ // Load from URL
+ structureMap = await this.loadFromUrl(reference);
+ } else {
+ // Load from file
+ structureMap = await this.loadFromFile(reference);
+ }
+
+ // Cache the result
+ if (structureMap) {
+ this.cache.set(reference, structureMap);
+ }
+
+ return structureMap;
+ } catch (error) {
+ console.error(`Error retrieving StructureMap ${reference}:`, error);
+ return null;
+ }
+ }
+
+ /**
+ * Load StructureMap from local file
+ */
+ private async loadFromFile(filename: string): Promise {
+ try {
+ const filePath = path.resolve(this.baseDirectory, filename);
+ const content = await fs.readFile(filePath, 'utf-8');
+ const structureMap = JSON.parse(content) as StructureMap;
+
+ // Basic validation
+ if (structureMap.resourceType !== 'StructureMap') {
+ throw new Error('Invalid StructureMap: resourceType must be "StructureMap"');
+ }
+
+ return structureMap;
+ } catch (error) {
+ console.error(`Error loading StructureMap from file ${filename}:`, error);
+ return null;
+ }
+ }
+
+ /**
+ * Load StructureMap from URL
+ */
+ private async loadFromUrl(url: string): Promise {
+ try {
+ // Note: Using fetch() available in Node.js 18+
+ // For older versions, would need to use a library like node-fetch
+ const response = await fetch(url);
+
+ if (!response.ok) {
+ throw new Error(`HTTP error! status: ${response.status}`);
+ }
+
+ const structureMap = await response.json() as StructureMap;
+
+ // Basic validation
+ if (structureMap.resourceType !== 'StructureMap') {
+ throw new Error('Invalid StructureMap: resourceType must be "StructureMap"');
+ }
+
+ return structureMap;
+ } catch (error) {
+ console.error(`Error loading StructureMap from URL ${url}:`, error);
+ return null;
+ }
+ }
+
+ /**
+ * Clear the cache
+ */
+ clearCache(): void {
+ this.cache.clear();
+ }
+
+ /**
+ * Set base directory for file loading
+ */
+ setBaseDirectory(directory: string): void {
+ this.baseDirectory = directory;
+ }
+}
\ No newline at end of file
diff --git a/src/lib/validation-service.ts b/src/lib/validation-service.ts
new file mode 100644
index 0000000..282eca6
--- /dev/null
+++ b/src/lib/validation-service.ts
@@ -0,0 +1,191 @@
+import { StructureDefinition, ValidationResult, ValidationError, ValidationWarning } from '../types';
+
+/**
+ * Basic validation service for FHIR resources
+ */
+export class ValidationService {
+ private structureDefinitions: Map = new Map();
+
+ /**
+ * Register a StructureDefinition for validation
+ */
+ registerStructureDefinition(structureDefinition: StructureDefinition): void {
+ if (structureDefinition.url) {
+ this.structureDefinitions.set(structureDefinition.url, structureDefinition);
+ }
+ if (structureDefinition.name && structureDefinition.name !== structureDefinition.url) {
+ this.structureDefinitions.set(structureDefinition.name, structureDefinition);
+ }
+ }
+
+ /**
+ * Validate a resource against a StructureDefinition
+ */
+ validate(resource: any, profileUrl: string): ValidationResult {
+ const errors: ValidationError[] = [];
+ const warnings: ValidationWarning[] = [];
+
+ try {
+ const structureDefinition = this.structureDefinitions.get(profileUrl);
+
+ if (!structureDefinition) {
+ errors.push({
+ path: '',
+ message: `StructureDefinition not found: ${profileUrl}`,
+ severity: 'error'
+ });
+ return { valid: false, errors, warnings };
+ }
+
+ // Basic validation - check resource type matches
+ if (resource.resourceType && resource.resourceType !== structureDefinition.type) {
+ errors.push({
+ path: 'resourceType',
+ message: `Expected resourceType '${structureDefinition.type}', but got '${resource.resourceType}'`,
+ severity: 'error'
+ });
+ }
+
+ // Validate against snapshot elements if available
+ if (structureDefinition.snapshot?.element) {
+ this.validateElements(resource, structureDefinition.snapshot.element, structureDefinition.type, errors, warnings);
+ }
+
+ } catch (error) {
+ errors.push({
+ path: '',
+ message: `Validation error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+ severity: 'error'
+ });
+ }
+
+ return {
+ valid: errors.length === 0,
+ errors,
+ warnings
+ };
+ }
+
+ /**
+ * Validate resource elements against ElementDefinitions
+ */
+ private validateElements(
+ resource: any,
+ elements: any[],
+ resourceType: string,
+ errors: ValidationError[],
+ warnings: ValidationWarning[]
+ ): void {
+ for (const element of elements) {
+ if (!element.path) continue;
+
+ const elementPath = element.path;
+ const value = this.getValueAtPath(resource, elementPath, resourceType);
+
+ // Skip root element validation for now (it's the resource itself)
+ if (elementPath === resourceType) {
+ continue;
+ }
+
+ // Check cardinality
+ if (element.min !== undefined && element.min > 0) {
+ if (value === undefined || value === null) {
+ errors.push({
+ path: elementPath,
+ message: `Required element '${elementPath}' is missing (min: ${element.min})`,
+ severity: 'error'
+ });
+ }
+ }
+
+ if (element.max !== undefined && element.max !== '*') {
+ const maxValue = parseInt(element.max, 10);
+ if (Array.isArray(value) && value.length > maxValue) {
+ errors.push({
+ path: elementPath,
+ message: `Too many values for '${elementPath}' (max: ${element.max}, found: ${value.length})`,
+ severity: 'error'
+ });
+ }
+ }
+
+ // Basic type checking
+ if (value !== undefined && element.type && element.type.length > 0) {
+ const expectedType = element.type[0].code;
+ if (!this.isValidType(value, expectedType)) {
+ warnings.push({
+ path: elementPath,
+ message: `Value at '${elementPath}' may not match expected type '${expectedType}'`,
+ severity: 'warning'
+ });
+ }
+ }
+ }
+ }
+
+ /**
+ * Get value at a given FHIR path (simplified implementation)
+ */
+ private getValueAtPath(resource: any, path: string, resourceType?: string): any {
+ if (!path || !resource) return undefined;
+
+ // Handle root resource path
+ if (path === resourceType) {
+ return resource;
+ }
+
+ const parts = path.split('.');
+ let current = resource;
+
+ // Skip the resource type part if it's the first part
+ let startIndex = 0;
+ if (parts[0] === resourceType) {
+ startIndex = 1;
+ }
+
+ for (let i = startIndex; i < parts.length; i++) {
+ if (current === null || current === undefined) return undefined;
+ current = current[parts[i]];
+ }
+
+ return current;
+ }
+
+ /**
+ * Basic type validation
+ */
+ private isValidType(value: any, expectedType: string): boolean {
+ switch (expectedType) {
+ case 'string':
+ return typeof value === 'string';
+ case 'boolean':
+ return typeof value === 'boolean';
+ case 'integer':
+ case 'decimal':
+ return typeof value === 'number';
+ case 'date':
+ case 'dateTime':
+ return typeof value === 'string' && !isNaN(Date.parse(value));
+ case 'code':
+ case 'uri':
+ case 'url':
+ return typeof value === 'string';
+ default:
+ return true; // Unknown type, assume valid
+ }
+ }
+
+ /**
+ * Clear all registered StructureDefinitions
+ */
+ clearStructureDefinitions(): void {
+ this.structureDefinitions.clear();
+ }
+
+ /**
+ * Get all registered StructureDefinitions
+ */
+ getStructureDefinitions(): StructureDefinition[] {
+ return Array.from(this.structureDefinitions.values());
+ }
+}
\ No newline at end of file
diff --git a/src/lib/valueset-service.ts b/src/lib/valueset-service.ts
new file mode 100644
index 0000000..38cb81c
--- /dev/null
+++ b/src/lib/valueset-service.ts
@@ -0,0 +1,246 @@
+import { ValueSet } from '../types';
+
+/**
+ * Service for managing ValueSet resources
+ */
+export class ValueSetService {
+ private valueSets: Map = new Map();
+
+ /**
+ * Register a ValueSet resource
+ */
+ registerValueSet(valueSet: ValueSet): void {
+ if (valueSet.id) {
+ this.valueSets.set(valueSet.id, valueSet);
+ }
+ if (valueSet.url) {
+ this.valueSets.set(valueSet.url, valueSet);
+ }
+ }
+
+ /**
+ * Get ValueSet by ID or URL
+ */
+ getValueSet(reference: string): ValueSet | null {
+ return this.valueSets.get(reference) || null;
+ }
+
+ /**
+ * Get all ValueSets
+ */
+ getAllValueSets(): ValueSet[] {
+ const unique = new Map();
+ this.valueSets.forEach((valueSet) => {
+ const key = valueSet.id || valueSet.url || Math.random().toString();
+ unique.set(key, valueSet);
+ });
+ return Array.from(unique.values());
+ }
+
+ /**
+ * Search ValueSets by parameters
+ */
+ searchValueSets(params: {
+ name?: string;
+ status?: string;
+ url?: string;
+ publisher?: string;
+ jurisdiction?: string;
+ }): ValueSet[] {
+ let results = this.getAllValueSets();
+
+ if (params.name) {
+ results = results.filter(vs =>
+ vs.name?.toLowerCase().includes(params.name!.toLowerCase()) ||
+ vs.title?.toLowerCase().includes(params.name!.toLowerCase())
+ );
+ }
+
+ if (params.status) {
+ results = results.filter(vs => vs.status === params.status);
+ }
+
+ if (params.url) {
+ results = results.filter(vs => vs.url === params.url);
+ }
+
+ if (params.publisher) {
+ results = results.filter(vs =>
+ vs.publisher?.toLowerCase().includes(params.publisher!.toLowerCase())
+ );
+ }
+
+ if (params.jurisdiction) {
+ results = results.filter(vs =>
+ vs.jurisdiction?.some(j =>
+ j.coding?.some(c => c.code === params.jurisdiction || c.display?.includes(params.jurisdiction!))
+ )
+ );
+ }
+
+ return results;
+ }
+
+ /**
+ * Remove ValueSet by ID or URL
+ */
+ removeValueSet(reference: string): boolean {
+ const valueSet = this.valueSets.get(reference);
+ if (valueSet) {
+ // Remove by both ID and URL if present
+ if (valueSet.id) {
+ this.valueSets.delete(valueSet.id);
+ }
+ if (valueSet.url) {
+ this.valueSets.delete(valueSet.url);
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Check if a code is in a ValueSet
+ */
+ validateCode(
+ valueSetRef: string,
+ system?: string,
+ code?: string,
+ display?: string
+ ): { result: boolean; message?: string } {
+ const valueSet = this.getValueSet(valueSetRef);
+ if (!valueSet) {
+ return { result: false, message: `ValueSet not found: ${valueSetRef}` };
+ }
+
+ // Check expanded codes first
+ if (valueSet.expansion?.contains) {
+ const found = this.findInExpansion(valueSet.expansion.contains, system, code, display);
+ if (found) {
+ return { result: true };
+ }
+ }
+
+ // Check compose includes
+ if (valueSet.compose?.include) {
+ for (const include of valueSet.compose.include) {
+ if (system && include.system && include.system !== system) {
+ continue;
+ }
+
+ // Check specific concepts
+ if (include.concept) {
+ for (const concept of include.concept) {
+ if (concept.code === code) {
+ if (!display || concept.display === display) {
+ return { result: true };
+ }
+ }
+ }
+ }
+
+ // If no specific concepts and system matches, assume code is valid
+ if (!include.concept && include.system === system && code) {
+ return { result: true };
+ }
+ }
+ }
+
+ return { result: false, message: `Code not found in ValueSet: ${code}` };
+ }
+
+ /**
+ * Helper method to search expansion
+ */
+ private findInExpansion(
+ contains: any[],
+ system?: string,
+ code?: string,
+ display?: string
+ ): boolean {
+ for (const item of contains) {
+ if (system && item.system && item.system !== system) {
+ continue;
+ }
+
+ if (item.code === code) {
+ if (!display || item.display === display) {
+ return true;
+ }
+ }
+
+ // Check nested contains
+ if (item.contains) {
+ if (this.findInExpansion(item.contains, system, code, display)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Expand a ValueSet (basic implementation)
+ */
+ expand(valueSetRef: string, count?: number, offset?: number): ValueSet | null {
+ const valueSet = this.getValueSet(valueSetRef);
+ if (!valueSet) {
+ return null;
+ }
+
+ // If already expanded, return as-is
+ if (valueSet.expansion) {
+ return valueSet;
+ }
+
+ // Basic expansion - would need code system lookup for full implementation
+ const expandedValueSet = { ...valueSet };
+ expandedValueSet.expansion = {
+ timestamp: new Date().toISOString(),
+ total: 0,
+ contains: []
+ };
+
+ if (valueSet.compose?.include) {
+ const allConcepts: any[] = [];
+ for (const include of valueSet.compose.include) {
+ if (include.concept) {
+ for (const concept of include.concept) {
+ allConcepts.push({
+ system: include.system,
+ code: concept.code,
+ display: concept.display
+ });
+ }
+ }
+ }
+
+ expandedValueSet.expansion.total = allConcepts.length;
+
+ if (offset) {
+ allConcepts.splice(0, offset);
+ }
+ if (count) {
+ allConcepts.splice(count);
+ }
+
+ expandedValueSet.expansion.contains = allConcepts;
+ }
+
+ return expandedValueSet;
+ }
+
+ /**
+ * Clear all ValueSets
+ */
+ clear(): void {
+ this.valueSets.clear();
+ }
+
+ /**
+ * Get count of registered ValueSets
+ */
+ getCount(): number {
+ return this.getAllValueSets().length;
+ }
+}
\ No newline at end of file
diff --git a/src/server.ts b/src/server.ts
new file mode 100644
index 0000000..308cab2
--- /dev/null
+++ b/src/server.ts
@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+import { FmlRunnerApi } from './api/server';
+import { FmlRunner } from './index';
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs(): { port: number; baseUrl: string } {
+ const args = process.argv.slice(2);
+ let port = parseInt(process.env.PORT || '3000', 10);
+ let baseUrl = process.env.BASE_URL || './maps';
+
+ for (let i = 0; i < args.length; i++) {
+ const arg = args[i];
+ if (arg === '--port' || arg === '-p') {
+ const portValue = args[i + 1];
+ if (portValue) {
+ const parsedPort = parseInt(portValue, 10);
+ if (!isNaN(parsedPort) && parsedPort > 0 && parsedPort <= 65535) {
+ port = parsedPort;
+ i++; // Skip the next argument as it's the port value
+ } else {
+ console.error(`Invalid port value: ${portValue}`);
+ process.exit(1);
+ }
+ }
+ } else if (arg === '--base-url' || arg === '-b') {
+ const baseUrlValue = args[i + 1];
+ if (baseUrlValue) {
+ baseUrl = baseUrlValue;
+ i++; // Skip the next argument as it's the base URL value
+ }
+ } else if (arg === '--help' || arg === '-h') {
+ console.log(`
+FML Runner API Server
+
+Usage: node server.js [options]
+
+Options:
+ -p, --port Port to listen on (default: 3000, env: PORT)
+ -b, --base-url Base directory for StructureMaps (default: ./maps, env: BASE_URL)
+ -h, --help Show this help message
+
+Environment Variables:
+ PORT Port to listen on
+ BASE_URL Base directory for StructureMaps
+ `);
+ process.exit(0);
+ }
+ }
+
+ return { port, baseUrl };
+}
+
+/**
+ * Standalone server entry point
+ */
+function main() {
+ const { port, baseUrl } = parseArgs();
+
+ const fmlRunner = new FmlRunner({ baseUrl });
+ const api = new FmlRunnerApi(fmlRunner);
+
+ api.listen(port);
+ console.log(`FML Runner API server started on port ${port}`);
+ console.log(`Base directory for StructureMaps: ${baseUrl}`);
+}
+
+if (require.main === module) {
+ main();
+}
\ No newline at end of file
diff --git a/src/types/fhirpath.d.ts b/src/types/fhirpath.d.ts
new file mode 100644
index 0000000..51c8ef9
--- /dev/null
+++ b/src/types/fhirpath.d.ts
@@ -0,0 +1,37 @@
+declare module 'fhirpath' {
+ /**
+ * Evaluate a FHIRPath expression against a resource
+ * @param resource - The FHIR resource or data to evaluate against
+ * @param expression - The FHIRPath expression to evaluate
+ * @param context - Optional context for the evaluation
+ * @returns Array of results from the evaluation
+ */
+ export function evaluate(resource: any, expression: string, context?: any): any[];
+
+ /**
+ * Parse a FHIRPath expression into an AST
+ * @param expression - The FHIRPath expression to parse
+ * @returns Parsed AST
+ */
+ export function parse(expression: string): any;
+
+ /**
+ * Compile a FHIRPath expression for faster repeated evaluation
+ * @param expression - The FHIRPath expression to compile
+ * @returns Compiled expression function
+ */
+ export function compile(expression: string): (resource: any, context?: any) => any[];
+
+ /**
+ * Library version
+ */
+ export const version: string;
+
+ /**
+ * Utility functions
+ */
+ export const util: any;
+ export const types: any;
+ export const ucumUtils: any;
+ export const resolveInternalTypes: any;
+}
\ No newline at end of file
diff --git a/src/types/index.ts b/src/types/index.ts
new file mode 100644
index 0000000..ef3b501
--- /dev/null
+++ b/src/types/index.ts
@@ -0,0 +1,534 @@
+/**
+ * Basic FHIR StructureMap types
+ */
+
+export interface StructureMap {
+ resourceType: 'StructureMap';
+ id?: string;
+ url?: string;
+ name?: string;
+ title?: string;
+ status: 'draft' | 'active' | 'retired' | 'unknown';
+ experimental?: boolean;
+ description?: string;
+ group: StructureMapGroup[];
+}
+
+export interface StructureMapGroup {
+ name: string;
+ typeMode?: 'none' | 'types' | 'type-and-types';
+ documentation?: string;
+ input: StructureMapGroupInput[];
+ rule: StructureMapGroupRule[];
+}
+
+export interface StructureMapGroupInput {
+ name: string;
+ type?: string;
+ mode: 'source' | 'target';
+ documentation?: string;
+}
+
+export interface StructureMapGroupRule {
+ name?: string;
+ source: StructureMapGroupRuleSource[];
+ target?: StructureMapGroupRuleTarget[];
+ documentation?: string;
+}
+
+export interface StructureMapGroupRuleSource {
+ context: string;
+ element?: string;
+ variable?: string;
+ type?: string;
+ min?: number;
+ max?: string;
+}
+
+export interface StructureMapGroupRuleTarget {
+ context?: string;
+ contextType?: 'variable' | 'type';
+ element?: string;
+ variable?: string;
+ transform?: string;
+ parameter?: any[];
+}
+
+/**
+ * FML compilation result
+ */
+export interface FmlCompilationResult {
+ success: boolean;
+ structureMap?: StructureMap;
+ errors?: string[];
+}
+
+/**
+ * StructureMap execution result
+ */
+export interface ExecutionResult {
+ success: boolean;
+ result?: any;
+ errors?: string[];
+}
+
+/**
+ * Configuration options
+ */
+export interface FmlRunnerOptions {
+ baseUrl?: string;
+ cacheEnabled?: boolean;
+ timeout?: number;
+ strictMode?: boolean; // New: Enable strict validation mode
+}
+
+/**
+ * FHIR StructureDefinition for logical models and validation
+ */
+export interface StructureDefinition {
+ resourceType: 'StructureDefinition';
+ id?: string;
+ url?: string;
+ name?: string;
+ title?: string;
+ status: 'draft' | 'active' | 'retired' | 'unknown';
+ kind: 'primitive-type' | 'complex-type' | 'resource' | 'logical';
+ abstract?: boolean;
+ type: string;
+ baseDefinition?: string;
+ derivation?: 'specialization' | 'constraint';
+ snapshot?: StructureDefinitionSnapshot;
+ differential?: StructureDefinitionDifferential;
+}
+
+export interface StructureDefinitionSnapshot {
+ element: ElementDefinition[];
+}
+
+export interface StructureDefinitionDifferential {
+ element: ElementDefinition[];
+}
+
+export interface ElementDefinition {
+ id?: string;
+ path: string;
+ sliceName?: string;
+ min?: number;
+ max?: string;
+ type?: ElementDefinitionType[];
+ binding?: ElementDefinitionBinding;
+}
+
+export interface ElementDefinitionType {
+ code: string;
+ profile?: string[];
+}
+
+export interface ElementDefinitionBinding {
+ strength?: 'required' | 'extensible' | 'preferred' | 'example';
+ valueSet?: string;
+}
+
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+ valid: boolean;
+ errors: ValidationError[];
+ warnings: ValidationWarning[];
+}
+
+export interface ValidationError {
+ path: string;
+ message: string;
+ severity: 'error';
+}
+
+export interface ValidationWarning {
+ path: string;
+ message: string;
+ severity: 'warning';
+}
+
+/**
+ * Enhanced execution options with validation
+ */
+export interface ExecutionOptions {
+ strictMode?: boolean;
+ validateInput?: boolean;
+ validateOutput?: boolean;
+ inputProfile?: string;
+ outputProfile?: string;
+}
+
+/**
+ * Enhanced execution result with validation details
+ */
+export interface EnhancedExecutionResult extends ExecutionResult {
+ validation?: {
+ input?: ValidationResult;
+ output?: ValidationResult;
+ };
+}
+
+/**
+ * FHIR ConceptMap resource for terminology mapping
+ */
+export interface ConceptMap {
+ resourceType: 'ConceptMap';
+ id?: string;
+ url?: string;
+ identifier?: Identifier[];
+ version?: string;
+ name?: string;
+ title?: string;
+ status: 'draft' | 'active' | 'retired' | 'unknown';
+ experimental?: boolean;
+ date?: string;
+ publisher?: string;
+ contact?: ContactDetail[];
+ description?: string;
+ useContext?: UsageContext[];
+ jurisdiction?: CodeableConcept[];
+ purpose?: string;
+ copyright?: string;
+ sourceUri?: string;
+ sourceCanonical?: string;
+ targetUri?: string;
+ targetCanonical?: string;
+ group?: ConceptMapGroup[];
+}
+
+export interface ConceptMapGroup {
+ source?: string;
+ sourceVersion?: string;
+ target?: string;
+ targetVersion?: string;
+ element: ConceptMapGroupElement[];
+ unmapped?: ConceptMapGroupUnmapped;
+}
+
+export interface ConceptMapGroupElement {
+ code?: string;
+ display?: string;
+ target?: ConceptMapGroupElementTarget[];
+}
+
+export interface ConceptMapGroupElementTarget {
+ code?: string;
+ display?: string;
+ equivalence: 'relatedto' | 'equivalent' | 'equal' | 'wider' | 'subsumes' | 'narrower' | 'specializes' | 'inexact' | 'unmatched' | 'disjoint';
+ comment?: string;
+ dependsOn?: ConceptMapGroupElementTargetDependsOn[];
+ product?: ConceptMapGroupElementTargetDependsOn[];
+}
+
+export interface ConceptMapGroupElementTargetDependsOn {
+ property: string;
+ system?: string;
+ value: string;
+ display?: string;
+}
+
+export interface ConceptMapGroupUnmapped {
+ mode: 'provided' | 'fixed' | 'other-map';
+ code?: string;
+ display?: string;
+ url?: string;
+}
+
+/**
+ * FHIR ValueSet resource for terminology sets
+ */
+export interface ValueSet {
+ resourceType: 'ValueSet';
+ id?: string;
+ url?: string;
+ identifier?: Identifier[];
+ version?: string;
+ name?: string;
+ title?: string;
+ status: 'draft' | 'active' | 'retired' | 'unknown';
+ experimental?: boolean;
+ date?: string;
+ publisher?: string;
+ contact?: ContactDetail[];
+ description?: string;
+ useContext?: UsageContext[];
+ jurisdiction?: CodeableConcept[];
+ immutable?: boolean;
+ purpose?: string;
+ copyright?: string;
+ compose?: ValueSetCompose;
+ expansion?: ValueSetExpansion;
+}
+
+export interface ValueSetCompose {
+ lockedDate?: string;
+ inactive?: boolean;
+ include: ValueSetComposeInclude[];
+ exclude?: ValueSetComposeInclude[];
+}
+
+export interface ValueSetComposeInclude {
+ system?: string;
+ version?: string;
+ concept?: ValueSetComposeIncludeConcept[];
+ filter?: ValueSetComposeIncludeFilter[];
+ valueSet?: string[];
+}
+
+export interface ValueSetComposeIncludeConcept {
+ code: string;
+ display?: string;
+ designation?: ValueSetComposeIncludeConceptDesignation[];
+}
+
+export interface ValueSetComposeIncludeConceptDesignation {
+ language?: string;
+ use?: Coding;
+ value: string;
+}
+
+export interface ValueSetComposeIncludeFilter {
+ property: string;
+ op: 'equals' | 'is-a' | 'descendent-of' | 'is-not-a' | 'regex' | 'in' | 'not-in' | 'generalizes' | 'exists';
+ value: string;
+}
+
+export interface ValueSetExpansion {
+ identifier?: string;
+ timestamp: string;
+ total?: number;
+ offset?: number;
+ parameter?: ValueSetExpansionParameter[];
+ contains?: ValueSetExpansionContains[];
+}
+
+export interface ValueSetExpansionParameter {
+ name: string;
+ valueString?: string;
+ valueBoolean?: boolean;
+ valueInteger?: number;
+ valueDecimal?: number;
+ valueUri?: string;
+ valueCode?: string;
+ valueDateTime?: string;
+}
+
+export interface ValueSetExpansionContains {
+ system?: string;
+ abstract?: boolean;
+ inactive?: boolean;
+ version?: string;
+ code?: string;
+ display?: string;
+ designation?: ValueSetComposeIncludeConceptDesignation[];
+ contains?: ValueSetExpansionContains[];
+}
+
+/**
+ * FHIR CodeSystem resource for terminology definitions
+ */
+export interface CodeSystem {
+ resourceType: 'CodeSystem';
+ id?: string;
+ url?: string;
+ identifier?: Identifier[];
+ version?: string;
+ name?: string;
+ title?: string;
+ status: 'draft' | 'active' | 'retired' | 'unknown';
+ experimental?: boolean;
+ date?: string;
+ publisher?: string;
+ contact?: ContactDetail[];
+ description?: string;
+ useContext?: UsageContext[];
+ jurisdiction?: CodeableConcept[];
+ purpose?: string;
+ copyright?: string;
+ caseSensitive?: boolean;
+ valueSet?: string;
+ hierarchyMeaning?: 'grouped-by' | 'is-a' | 'part-of' | 'classified-with';
+ compositional?: boolean;
+ versionNeeded?: boolean;
+ content: 'not-present' | 'example' | 'fragment' | 'complete' | 'supplement';
+ supplements?: string;
+ count?: number;
+ filter?: CodeSystemFilter[];
+ property?: CodeSystemProperty[];
+ concept?: CodeSystemConcept[];
+}
+
+export interface CodeSystemFilter {
+ code: string;
+ description?: string;
+ operator: ('equals' | 'is-a' | 'descendent-of' | 'is-not-a' | 'regex' | 'in' | 'not-in' | 'generalizes' | 'exists')[];
+ value: string;
+}
+
+export interface CodeSystemProperty {
+ code: string;
+ uri?: string;
+ description?: string;
+ type: 'code' | 'Coding' | 'string' | 'integer' | 'boolean' | 'dateTime' | 'decimal';
+}
+
+export interface CodeSystemConcept {
+ code: string;
+ display?: string;
+ definition?: string;
+ designation?: CodeSystemConceptDesignation[];
+ property?: CodeSystemConceptProperty[];
+ concept?: CodeSystemConcept[];
+}
+
+export interface CodeSystemConceptDesignation {
+ language?: string;
+ use?: Coding;
+ value: string;
+}
+
+export interface CodeSystemConceptProperty {
+ code: string;
+ valueCode?: string;
+ valueCoding?: Coding;
+ valueString?: string;
+ valueInteger?: number;
+ valueBoolean?: boolean;
+ valueDateTime?: string;
+ valueDecimal?: number;
+}
+
+/**
+ * Common FHIR data types
+ */
+export interface Identifier {
+ use?: 'usual' | 'official' | 'temp' | 'secondary' | 'old';
+ type?: CodeableConcept;
+ system?: string;
+ value?: string;
+ period?: Period;
+ assigner?: Reference;
+}
+
+export interface ContactDetail {
+ name?: string;
+ telecom?: ContactPoint[];
+}
+
+export interface ContactPoint {
+ system?: 'phone' | 'fax' | 'email' | 'pager' | 'url' | 'sms' | 'other';
+ value?: string;
+ use?: 'home' | 'work' | 'temp' | 'old' | 'mobile';
+ rank?: number;
+ period?: Period;
+}
+
+export interface UsageContext {
+ code: Coding;
+ valueCodeableConcept?: CodeableConcept;
+ valueQuantity?: Quantity;
+ valueRange?: Range;
+ valueReference?: Reference;
+}
+
+export interface CodeableConcept {
+ coding?: Coding[];
+ text?: string;
+}
+
+export interface Coding {
+ system?: string;
+ version?: string;
+ code?: string;
+ display?: string;
+ userSelected?: boolean;
+}
+
+export interface Period {
+ start?: string;
+ end?: string;
+}
+
+export interface Reference {
+ reference?: string;
+ type?: string;
+ identifier?: Identifier;
+ display?: string;
+}
+
+export interface Quantity {
+ value?: number;
+ comparator?: '<' | '<=' | '>=' | '>';
+ unit?: string;
+ system?: string;
+ code?: string;
+}
+
+export interface Range {
+ low?: Quantity;
+ high?: Quantity;
+}
+
+/**
+ * FHIR Bundle for bulk operations
+ */
+export interface Bundle {
+ resourceType: 'Bundle';
+ id?: string;
+ identifier?: Identifier;
+ type: 'document' | 'message' | 'transaction' | 'transaction-response' | 'batch' | 'batch-response' | 'history' | 'searchset' | 'collection';
+ timestamp?: string;
+ total?: number;
+ link?: BundleLink[];
+ entry?: BundleEntry[];
+ signature?: Signature;
+}
+
+export interface BundleLink {
+ relation: string;
+ url: string;
+}
+
+export interface BundleEntry {
+ link?: BundleLink[];
+ fullUrl?: string;
+ resource?: any; // Can be any FHIR resource
+ search?: BundleEntrySearch;
+ request?: BundleEntryRequest;
+ response?: BundleEntryResponse;
+}
+
+export interface BundleEntrySearch {
+ mode?: 'match' | 'include' | 'outcome';
+ score?: number;
+}
+
+export interface BundleEntryRequest {
+ method: 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+ url: string;
+ ifNoneMatch?: string;
+ ifModifiedSince?: string;
+ ifMatch?: string;
+ ifNoneExist?: string;
+}
+
+export interface BundleEntryResponse {
+ status: string;
+ location?: string;
+ etag?: string;
+ lastModified?: string;
+ outcome?: any;
+}
+
+export interface Signature {
+ type: Coding[];
+ when: string;
+ who: Reference;
+ onBehalfOf?: Reference;
+ targetFormat?: string;
+ sigFormat?: string;
+ data?: string;
+}
\ No newline at end of file
diff --git a/tests/api.test.ts b/tests/api.test.ts
new file mode 100644
index 0000000..5121e93
--- /dev/null
+++ b/tests/api.test.ts
@@ -0,0 +1,465 @@
+import request from 'supertest';
+import { FmlRunnerApi } from '../src/api/server';
+import { FmlRunner } from '../src';
+import * as path from 'path';
+
+describe('FmlRunnerApi', () => {
+ let api: FmlRunnerApi;
+ let app: any;
+ const testDataDir = path.join(__dirname, 'test-data');
+
+ beforeEach(() => {
+ const fmlRunner = new FmlRunner({ baseUrl: testDataDir });
+ api = new FmlRunnerApi(fmlRunner);
+ app = api.getApp();
+ });
+
+ describe('POST /api/v1/compile', () => {
+ it('should compile valid FML content', async () => {
+ const fmlContent = `
+ map "http://example.org/StructureMap/test" = "TestMap"
+ source -> target
+ `;
+
+ const response = await request(app)
+ .post('/api/v1/compile')
+ .send({ fmlContent })
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('StructureMap');
+ expect(response.body.name).toBe('TestMap');
+ });
+
+ it('should return 400 for missing fmlContent', async () => {
+ const response = await request(app)
+ .post('/api/v1/compile')
+ .send({})
+ .expect(400);
+
+ expect(response.body.error).toBe('fmlContent is required');
+ });
+
+ it('should return 400 for empty fmlContent', async () => {
+ const response = await request(app)
+ .post('/api/v1/compile')
+ .send({ fmlContent: '' })
+ .expect(400);
+
+ expect(response.body.error).toBe('fmlContent is required');
+ });
+ });
+
+ describe('POST /api/v1/execute', () => {
+ it('should execute StructureMap transformation', async () => {
+ const requestBody = {
+ structureMapReference: 'test-structure-map.json',
+ inputContent: { name: 'John Doe' }
+ };
+
+ const response = await request(app)
+ .post('/api/v1/execute')
+ .send(requestBody)
+ .expect(200);
+
+ expect(response.body.result).toEqual({ fullName: 'John Doe' });
+ });
+
+ it('should return 400 for missing parameters', async () => {
+ const response = await request(app)
+ .post('/api/v1/execute')
+ .send({ structureMapReference: 'test.json' })
+ .expect(400);
+
+ expect(response.body.error).toContain('structureMapReference and inputContent are required');
+ });
+
+ it('should return 400 for non-existent StructureMap', async () => {
+ const requestBody = {
+ structureMapReference: 'non-existent.json',
+ inputContent: { test: 'data' }
+ };
+
+ const response = await request(app)
+ .post('/api/v1/execute')
+ .send(requestBody)
+ .expect(400);
+
+ expect(response.body.error).toBe('StructureMap execution failed');
+ });
+ });
+
+ describe('GET /api/v1/structuremap/:reference', () => {
+ it('should retrieve existing StructureMap', async () => {
+ const response = await request(app)
+ .get('/api/v1/structuremap/test-structure-map.json')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('StructureMap');
+ expect(response.body.name).toBe('TestMap');
+ });
+
+ it('should return 404 for non-existent StructureMap', async () => {
+ const response = await request(app)
+ .get('/api/v1/structuremap/non-existent.json')
+ .expect(404);
+
+ expect(response.body.error).toBe('StructureMap not found');
+ });
+ });
+
+ describe('FHIR-compliant StructureMap endpoints', () => {
+ describe('GET /api/v1/StructureMap', () => {
+ it('should return empty bundle for search', async () => {
+ const response = await request(app)
+ .get('/api/v1/StructureMap')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Bundle');
+ expect(response.body.type).toBe('searchset');
+ expect(response.body.total).toBe(0);
+ });
+
+ it('should accept FHIR search parameters', async () => {
+ const response = await request(app)
+ .get('/api/v1/StructureMap?name=test&status=active&_count=10')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Bundle');
+ });
+ });
+
+ describe('GET /api/v1/StructureMap/:id', () => {
+ it('should retrieve StructureMap by ID', async () => {
+ const response = await request(app)
+ .get('/api/v1/StructureMap/test-structure-map.json')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('StructureMap');
+ expect(response.body.name).toBe('TestMap');
+ });
+
+ it('should return FHIR OperationOutcome for not found', async () => {
+ const response = await request(app)
+ .get('/api/v1/StructureMap/non-existent')
+ .expect(404);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].severity).toBe('error');
+ expect(response.body.issue[0].code).toBe('not-found');
+ });
+ });
+
+ describe('POST /api/v1/StructureMap', () => {
+ it('should create new StructureMap', async () => {
+ const structureMap = {
+ resourceType: 'StructureMap',
+ name: 'NewMap',
+ status: 'draft',
+ group: [{
+ name: 'main',
+ input: [{ name: 'source', mode: 'source' }],
+ rule: []
+ }]
+ };
+
+ const response = await request(app)
+ .post('/api/v1/StructureMap')
+ .send(structureMap)
+ .expect(201);
+
+ expect(response.body.resourceType).toBe('StructureMap');
+ expect(response.body.name).toBe('NewMap');
+ expect(response.body.id).toBeDefined();
+ });
+
+ it('should return FHIR OperationOutcome for invalid resource', async () => {
+ const response = await request(app)
+ .post('/api/v1/StructureMap')
+ .send({ resourceType: 'Patient' })
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].code).toBe('invalid');
+ });
+ });
+
+ describe('PUT /api/v1/StructureMap/:id', () => {
+ it('should update existing StructureMap', async () => {
+ const structureMap = {
+ resourceType: 'StructureMap',
+ name: 'UpdatedMap',
+ status: 'active',
+ group: [{
+ name: 'main',
+ input: [{ name: 'source', mode: 'source' }],
+ rule: []
+ }]
+ };
+
+ const response = await request(app)
+ .put('/api/v1/StructureMap/test-id')
+ .send(structureMap)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('StructureMap');
+ expect(response.body.id).toBe('test-id');
+ });
+ });
+
+ describe('DELETE /api/v1/StructureMap/:id', () => {
+ it('should delete StructureMap', async () => {
+ await request(app)
+ .delete('/api/v1/StructureMap/test-id')
+ .expect(204);
+ });
+ });
+ });
+
+ describe('POST /api/v1/StructureMap/\\$transform', () => {
+ it('should transform using FHIR Parameters', async () => {
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ {
+ name: 'source',
+ resource: { name: 'Jane Doe' }
+ },
+ {
+ name: 'map',
+ valueString: 'test-structure-map.json'
+ }
+ ]
+ };
+
+ const response = await request(app)
+ .post('/api/v1/StructureMap/$transform')
+ .send(parameters)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Parameters');
+ expect(response.body.parameter[0].name).toBe('result');
+ expect(response.body.parameter[0].resource.fullName).toBe('Jane Doe');
+ });
+
+ it('should return OperationOutcome for invalid Parameters', async () => {
+ const response = await request(app)
+ .post('/api/v1/StructureMap/$transform')
+ .send({ resourceType: 'Bundle' })
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].code).toBe('invalid');
+ });
+
+ it('should return OperationOutcome for missing parameters', async () => {
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ {
+ name: 'source',
+ resource: { name: 'Test' }
+ }
+ ]
+ };
+
+ const response = await request(app)
+ .post('/api/v1/StructureMap/$transform')
+ .send(parameters)
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].diagnostics).toContain('source" and "map" parameters');
+ });
+
+ it('should return OperationOutcome for transformation failure', async () => {
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ {
+ name: 'source',
+ resource: { name: 'Test' }
+ },
+ {
+ name: 'map',
+ valueString: 'non-existent.json'
+ }
+ ]
+ };
+
+ const response = await request(app)
+ .post('/api/v1/StructureMap/$transform')
+ .send(parameters)
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].code).toBe('processing');
+ });
+ });
+
+ describe('StructureDefinition endpoints', () => {
+ describe('GET /api/v1/StructureDefinition', () => {
+ it('should return empty bundle initially', async () => {
+ const response = await request(app)
+ .get('/api/v1/StructureDefinition')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Bundle');
+ expect(response.body.type).toBe('searchset');
+ expect(response.body.total).toBe(0);
+ });
+ });
+
+ describe('POST /api/v1/StructureDefinition', () => {
+ it('should create new StructureDefinition', async () => {
+ const structureDefinition = {
+ resourceType: 'StructureDefinition',
+ name: 'TestProfile',
+ status: 'draft',
+ kind: 'logical',
+ type: 'TestResource',
+ snapshot: {
+ element: [
+ {
+ path: 'TestResource',
+ min: 1,
+ max: '1'
+ }
+ ]
+ }
+ };
+
+ const response = await request(app)
+ .post('/api/v1/StructureDefinition')
+ .send(structureDefinition)
+ .expect(201);
+
+ expect(response.body.resourceType).toBe('StructureDefinition');
+ expect(response.body.name).toBe('TestProfile');
+ expect(response.body.id).toBeDefined();
+ });
+ });
+
+ describe('GET /api/v1/StructureDefinition/:id', () => {
+ it('should return 404 for non-existent StructureDefinition', async () => {
+ const response = await request(app)
+ .get('/api/v1/StructureDefinition/non-existent')
+ .expect(404);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ });
+ });
+ });
+
+ describe('Validation endpoints', () => {
+ beforeEach(async () => {
+ // Register a StructureDefinition for testing
+ const structureDefinition = {
+ resourceType: 'StructureDefinition',
+ url: 'http://example.org/StructureDefinition/TestPatient',
+ name: 'TestPatient',
+ status: 'active',
+ kind: 'resource',
+ type: 'Patient',
+ snapshot: {
+ element: [
+ {
+ path: 'Patient',
+ min: 1,
+ max: '1'
+ },
+ {
+ path: 'Patient.name',
+ min: 1,
+ max: '*',
+ type: [{ code: 'string' }]
+ }
+ ]
+ }
+ };
+
+ await request(app)
+ .post('/api/v1/StructureDefinition')
+ .send(structureDefinition);
+ });
+
+ describe('POST /api/v1/validate', () => {
+ it('should validate valid resource', async () => {
+ const requestBody = {
+ resource: {
+ resourceType: 'Patient',
+ name: 'John Doe'
+ },
+ profile: 'http://example.org/StructureDefinition/TestPatient'
+ };
+
+ const response = await request(app)
+ .post('/api/v1/validate')
+ .send(requestBody)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue).toBeDefined();
+ });
+
+ it('should return validation errors for invalid resource', async () => {
+ const requestBody = {
+ resource: {
+ resourceType: 'Patient'
+ // Missing required name field
+ },
+ profile: 'http://example.org/StructureDefinition/TestPatient'
+ };
+
+ const response = await request(app)
+ .post('/api/v1/validate')
+ .send(requestBody)
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue.length).toBeGreaterThan(0);
+ expect(response.body.issue[0].severity).toBe('error');
+ });
+
+ it('should return 400 for missing parameters', async () => {
+ const response = await request(app)
+ .post('/api/v1/validate')
+ .send({ resource: {} })
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].diagnostics).toContain('resource and profile are required');
+ });
+ });
+
+ describe('POST /api/v1/execute-with-validation', () => {
+ it('should execute with validation (basic test)', async () => {
+ const requestBody = {
+ structureMapReference: 'test-structure-map.json',
+ inputContent: { name: 'John Doe' },
+ options: {
+ strictMode: false
+ }
+ };
+
+ const response = await request(app)
+ .post('/api/v1/execute-with-validation')
+ .send(requestBody)
+ .expect(200);
+
+ expect(response.body.result).toBeDefined();
+ });
+ });
+ });
+
+ describe('GET /api/v1/health', () => {
+ it('should return health status', async () => {
+ const response = await request(app)
+ .get('/api/v1/health')
+ .expect(200);
+
+ expect(response.body.status).toBe('healthy');
+ expect(response.body.version).toBe('0.1.0');
+ expect(response.body.timestamp).toBeDefined();
+ });
+ });
+});
\ No newline at end of file
diff --git a/tests/enhanced-api.test.ts b/tests/enhanced-api.test.ts
new file mode 100644
index 0000000..8fcd6cf
--- /dev/null
+++ b/tests/enhanced-api.test.ts
@@ -0,0 +1,454 @@
+import request from 'supertest';
+import { FmlRunnerApi } from '../src/api/server';
+import { FmlRunner } from '../src/index';
+
+describe('Enhanced FHIR Resource API Tests', () => {
+ let app: any;
+ let fmlRunner: FmlRunner;
+
+ beforeEach(() => {
+ fmlRunner = new FmlRunner();
+ const api = new FmlRunnerApi(fmlRunner);
+ app = api.getApp();
+ });
+
+ describe('Bundle Processing', () => {
+ describe('POST /api/v1/Bundle', () => {
+ it('should process a bundle with multiple resource types', async () => {
+ const bundle = {
+ resourceType: 'Bundle',
+ type: 'collection',
+ entry: [
+ {
+ resource: {
+ resourceType: 'ConceptMap',
+ id: 'test-cm',
+ url: 'http://example.org/ConceptMap/test',
+ status: 'active',
+ sourceUri: 'http://example.org/vs1',
+ targetUri: 'http://example.org/vs2',
+ group: [{
+ source: 'http://example.org/cs1',
+ target: 'http://example.org/cs2',
+ element: [{
+ code: 'A',
+ target: [{
+ code: 'B',
+ equivalence: 'equivalent'
+ }]
+ }]
+ }]
+ }
+ },
+ {
+ resource: {
+ resourceType: 'ValueSet',
+ id: 'test-vs',
+ url: 'http://example.org/ValueSet/test',
+ status: 'active',
+ compose: {
+ include: [{
+ system: 'http://example.org/cs1',
+ concept: [
+ { code: 'A', display: 'Alpha' },
+ { code: 'B', display: 'Beta' }
+ ]
+ }]
+ }
+ }
+ },
+ {
+ resource: {
+ resourceType: 'CodeSystem',
+ id: 'test-cs',
+ url: 'http://example.org/CodeSystem/test',
+ status: 'active',
+ content: 'complete',
+ concept: [
+ { code: 'A', display: 'Alpha' },
+ { code: 'B', display: 'Beta' }
+ ]
+ }
+ }
+ ]
+ };
+
+ const response = await request(app)
+ .post('/api/v1/Bundle')
+ .send(bundle)
+ .expect(201);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].severity).toBe('information');
+ expect(response.body.issue[0].diagnostics).toContain('1 ConceptMaps');
+ expect(response.body.issue[0].diagnostics).toContain('1 ValueSets');
+ expect(response.body.issue[0].diagnostics).toContain('1 CodeSystems');
+ });
+
+ it('should return error for invalid bundle', async () => {
+ const response = await request(app)
+ .post('/api/v1/Bundle')
+ .send({ invalid: 'data' })
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ expect(response.body.issue[0].code).toBe('invalid');
+ });
+ });
+
+ describe('GET /api/v1/Bundle/summary', () => {
+ it('should return summary of loaded resources', async () => {
+ const response = await request(app)
+ .get('/api/v1/Bundle/summary')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Bundle');
+ expect(response.body.type).toBe('collection');
+ });
+ });
+ });
+
+ describe('ConceptMap CRUD Operations', () => {
+ const testConceptMap = {
+ resourceType: 'ConceptMap',
+ name: 'TestConceptMap',
+ status: 'active',
+ sourceUri: 'http://example.org/vs1',
+ targetUri: 'http://example.org/vs2',
+ group: [{
+ source: 'http://example.org/cs1',
+ target: 'http://example.org/cs2',
+ element: [{
+ code: 'A',
+ target: [{
+ code: 'B',
+ equivalence: 'equivalent'
+ }]
+ }]
+ }]
+ };
+
+ describe('POST /api/v1/ConceptMap', () => {
+ it('should create a new ConceptMap', async () => {
+ const response = await request(app)
+ .post('/api/v1/ConceptMap')
+ .send(testConceptMap)
+ .expect(201);
+
+ expect(response.body.resourceType).toBe('ConceptMap');
+ expect(response.body.name).toBe('TestConceptMap');
+ expect(response.body.id).toBeDefined();
+ });
+
+ it('should reject invalid ConceptMap', async () => {
+ const response = await request(app)
+ .post('/api/v1/ConceptMap')
+ .send({ resourceType: 'Invalid' })
+ .expect(400);
+
+ expect(response.body.resourceType).toBe('OperationOutcome');
+ });
+ });
+
+ describe('GET /api/v1/ConceptMap', () => {
+ it('should search ConceptMaps', async () => {
+ const response = await request(app)
+ .get('/api/v1/ConceptMap')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Bundle');
+ expect(response.body.type).toBe('searchset');
+ });
+ });
+
+ describe('POST /api/v1/ConceptMap/$translate', () => {
+ it('should translate codes using loaded ConceptMaps', async () => {
+ // First, create a ConceptMap
+ await request(app)
+ .post('/api/v1/ConceptMap')
+ .send(testConceptMap)
+ .expect(201);
+
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'system', valueUri: 'http://example.org/cs1' },
+ { name: 'code', valueCode: 'A' },
+ { name: 'target', valueUri: 'http://example.org/cs2' }
+ ]
+ };
+
+ const response = await request(app)
+ .post('/api/v1/ConceptMap/$translate')
+ .send(parameters)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Parameters');
+ expect(response.body.parameter).toBeDefined();
+ });
+ });
+ });
+
+ describe('ValueSet CRUD Operations', () => {
+ const testValueSet = {
+ resourceType: 'ValueSet',
+ name: 'TestValueSet',
+ status: 'active',
+ compose: {
+ include: [{
+ system: 'http://example.org/cs1',
+ concept: [
+ { code: 'A', display: 'Alpha' },
+ { code: 'B', display: 'Beta' }
+ ]
+ }]
+ }
+ };
+
+ describe('POST /api/v1/ValueSet', () => {
+ it('should create a new ValueSet', async () => {
+ const response = await request(app)
+ .post('/api/v1/ValueSet')
+ .send(testValueSet)
+ .expect(201);
+
+ expect(response.body.resourceType).toBe('ValueSet');
+ expect(response.body.name).toBe('TestValueSet');
+ expect(response.body.id).toBeDefined();
+ });
+ });
+
+ describe('GET /api/v1/ValueSet', () => {
+ it('should search ValueSets', async () => {
+ const response = await request(app)
+ .get('/api/v1/ValueSet')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Bundle');
+ expect(response.body.type).toBe('searchset');
+ });
+ });
+
+ describe('POST /api/v1/ValueSet/$expand', () => {
+ it('should expand ValueSet', async () => {
+ // First, create a ValueSet
+ const createResponse = await request(app)
+ .post('/api/v1/ValueSet')
+ .send(testValueSet)
+ .expect(201);
+
+ const valueSetId = createResponse.body.id;
+
+ const response = await request(app)
+ .post(`/api/v1/ValueSet/${valueSetId}/$expand`)
+ .send({ resourceType: 'Parameters', parameter: [] })
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('ValueSet');
+ expect(response.body.expansion).toBeDefined();
+ });
+ });
+
+ describe('POST /api/v1/ValueSet/$validate-code', () => {
+ it('should validate code in ValueSet', async () => {
+ // First, create a ValueSet
+ const createResponse = await request(app)
+ .post('/api/v1/ValueSet')
+ .send(testValueSet)
+ .expect(201);
+
+ const valueSetId = createResponse.body.id;
+
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'system', valueUri: 'http://example.org/cs1' },
+ { name: 'code', valueCode: 'A' }
+ ]
+ };
+
+ const response = await request(app)
+ .post(`/api/v1/ValueSet/${valueSetId}/$validate-code`)
+ .send(parameters)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Parameters');
+ expect(response.body.parameter).toBeDefined();
+ expect(response.body.parameter.find((p: any) => p.name === 'result')?.valueBoolean).toBe(true);
+ });
+ });
+ });
+
+ describe('CodeSystem CRUD Operations', () => {
+ const testCodeSystem = {
+ resourceType: 'CodeSystem',
+ name: 'TestCodeSystem',
+ status: 'active',
+ content: 'complete',
+ concept: [
+ { code: 'A', display: 'Alpha', definition: 'First letter' },
+ { code: 'B', display: 'Beta', definition: 'Second letter' }
+ ]
+ };
+
+ describe('POST /api/v1/CodeSystem', () => {
+ it('should create a new CodeSystem', async () => {
+ const response = await request(app)
+ .post('/api/v1/CodeSystem')
+ .send(testCodeSystem)
+ .expect(201);
+
+ expect(response.body.resourceType).toBe('CodeSystem');
+ expect(response.body.name).toBe('TestCodeSystem');
+ expect(response.body.id).toBeDefined();
+ });
+ });
+
+ describe('GET /api/v1/CodeSystem', () => {
+ it('should search CodeSystems', async () => {
+ const response = await request(app)
+ .get('/api/v1/CodeSystem')
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Bundle');
+ expect(response.body.type).toBe('searchset');
+ });
+ });
+
+ describe('POST /api/v1/CodeSystem/$lookup', () => {
+ it('should lookup concept in CodeSystem', async () => {
+ // First, create a CodeSystem
+ const createResponse = await request(app)
+ .post('/api/v1/CodeSystem')
+ .send(testCodeSystem)
+ .expect(201);
+
+ const codeSystemId = createResponse.body.id;
+
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'code', valueCode: 'A' }
+ ]
+ };
+
+ const response = await request(app)
+ .post(`/api/v1/CodeSystem/${codeSystemId}/$lookup`)
+ .send(parameters)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Parameters');
+ expect(response.body.parameter).toBeDefined();
+ expect(response.body.parameter.find((p: any) => p.name === 'display')?.valueString).toBe('Alpha');
+ });
+ });
+
+ describe('POST /api/v1/CodeSystem/$validate-code', () => {
+ it('should validate code in CodeSystem', async () => {
+ // First, create a CodeSystem
+ const createResponse = await request(app)
+ .post('/api/v1/CodeSystem')
+ .send(testCodeSystem)
+ .expect(201);
+
+ const codeSystemId = createResponse.body.id;
+
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'code', valueCode: 'A' }
+ ]
+ };
+
+ const response = await request(app)
+ .post(`/api/v1/CodeSystem/${codeSystemId}/$validate-code`)
+ .send(parameters)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Parameters');
+ expect(response.body.parameter).toBeDefined();
+ expect(response.body.parameter.find((p: any) => p.name === 'result')?.valueBoolean).toBe(true);
+ });
+ });
+
+ describe('POST /api/v1/CodeSystem/$subsumes', () => {
+ it('should test subsumption between codes', async () => {
+ // First, create a CodeSystem
+ const createResponse = await request(app)
+ .post('/api/v1/CodeSystem')
+ .send(testCodeSystem)
+ .expect(201);
+
+ const codeSystemId = createResponse.body.id;
+
+ const parameters = {
+ resourceType: 'Parameters',
+ parameter: [
+ { name: 'codeA', valueCode: 'A' },
+ { name: 'codeB', valueCode: 'B' }
+ ]
+ };
+
+ const response = await request(app)
+ .post(`/api/v1/CodeSystem/${codeSystemId}/$subsumes`)
+ .send(parameters)
+ .expect(200);
+
+ expect(response.body.resourceType).toBe('Parameters');
+ expect(response.body.parameter).toBeDefined();
+ expect(response.body.parameter.find((p: any) => p.name === 'outcome')?.valueCode).toBeDefined();
+ });
+ });
+ });
+
+ describe('Library API Integration', () => {
+ it('should allow direct library access to all resource types', () => {
+ // Test ConceptMap methods
+ const conceptMap = {
+ resourceType: 'ConceptMap' as const,
+ id: 'test-cm',
+ status: 'active' as const
+ };
+ fmlRunner.registerConceptMap(conceptMap);
+ expect(fmlRunner.getConceptMap('test-cm')).toEqual(conceptMap);
+ expect(fmlRunner.getAllConceptMaps()).toContain(conceptMap);
+
+ // Test ValueSet methods
+ const valueSet = {
+ resourceType: 'ValueSet' as const,
+ id: 'test-vs',
+ status: 'active' as const
+ };
+ fmlRunner.registerValueSet(valueSet);
+ expect(fmlRunner.getValueSet('test-vs')).toEqual(valueSet);
+ expect(fmlRunner.getAllValueSets()).toContain(valueSet);
+
+ // Test CodeSystem methods
+ const codeSystem = {
+ resourceType: 'CodeSystem' as const,
+ id: 'test-cs',
+ status: 'active' as const,
+ content: 'complete' as const
+ };
+ fmlRunner.registerCodeSystem(codeSystem);
+ expect(fmlRunner.getCodeSystem('test-cs')).toEqual(codeSystem);
+ expect(fmlRunner.getAllCodeSystems()).toContain(codeSystem);
+
+ // Test Bundle processing
+ const bundle = {
+ resourceType: 'Bundle' as const,
+ type: 'collection' as const,
+ entry: [
+ { resource: conceptMap },
+ { resource: valueSet },
+ { resource: codeSystem }
+ ]
+ };
+ const result = fmlRunner.processBundle(bundle);
+ expect(result.success).toBe(true);
+ expect(result.processed.conceptMaps).toBe(1);
+ expect(result.processed.valueSets).toBe(1);
+ expect(result.processed.codeSystems).toBe(1);
+ });
+ });
+});
\ No newline at end of file
diff --git a/tests/enhanced-tokenizer.test.ts b/tests/enhanced-tokenizer.test.ts
new file mode 100644
index 0000000..774f98c
--- /dev/null
+++ b/tests/enhanced-tokenizer.test.ts
@@ -0,0 +1,151 @@
+import { FmlCompiler } from '../src/lib/fml-compiler';
+
+describe('Enhanced FML Tokenizer', () => {
+ let compiler: FmlCompiler;
+
+ beforeEach(() => {
+ compiler = new FmlCompiler();
+ });
+
+ test('should handle multi-line comments', () => {
+ const fmlWithMultiLineComment = `
+ /* This is a multi-line comment
+ spanning multiple lines */
+ map "http://example.org/test" = "TestMap"
+
+ group main(source : Patient) {
+ name : source.name -> target.name;
+ }
+ `;
+
+ const result = compiler.compile(fmlWithMultiLineComment);
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.url).toBe('http://example.org/test');
+ expect(result.structureMap?.name).toBe('TestMap');
+ });
+
+ test('should handle documentation comments', () => {
+ const fmlWithDocComment = `
+ /// This is a documentation comment
+ map "http://example.org/test2" = "TestMap2"
+
+ group main(source : Patient) {
+ name : source.name -> target.name;
+ }
+ `;
+
+ const result = compiler.compile(fmlWithDocComment);
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.url).toBe('http://example.org/test2');
+ expect(result.structureMap?.name).toBe('TestMap2');
+ });
+
+ test('should handle prefix declarations', () => {
+ const fmlWithPrefix = `
+ map "http://example.org/test3" = "TestMap3"
+ prefix system = "http://terminology.hl7.org/CodeSystem/v3-ActCode"
+
+ group main(source : Patient) {
+ name : source.name -> target.name;
+ }
+ `;
+
+ const result = compiler.compile(fmlWithPrefix);
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.url).toBe('http://example.org/test3');
+ expect(result.structureMap?.name).toBe('TestMap3');
+ });
+
+ test('should handle conceptmap declarations', () => {
+ const fmlWithConceptMap = `
+ map "http://example.org/test4" = "TestMap4"
+ conceptmap "http://example.org/conceptmap" {
+ target "http://terminology.hl7.org/CodeSystem/observation-category"
+ element[0].target.code = "survey"
+ }
+
+ group main(source : Patient) {
+ name : source.name -> target.name;
+ }
+ `;
+
+ const result = compiler.compile(fmlWithConceptMap);
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.url).toBe('http://example.org/test4');
+ expect(result.structureMap?.name).toBe('TestMap4');
+ });
+
+ test('should handle all enhanced preamble features combined', () => {
+ const fmlWithAllFeatures = `
+ /* Multi-line comment explaining the mapping */
+ /// Documentation for this map
+ map "http://example.org/comprehensive" = "ComprehensiveMap"
+
+ prefix loinc = "http://loinc.org"
+ uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as source
+ imports "http://example.org/other-map"
+
+ conceptmap "http://example.org/codes" {
+ target "http://terminology.hl7.org/CodeSystem/observation-category"
+ }
+
+ group main(source Patient : Patient, target : Patient) {
+ // Single line comment
+ name : source.name -> target.name;
+ }
+ `;
+
+ const result = compiler.compile(fmlWithAllFeatures);
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.url).toBe('http://example.org/comprehensive');
+ expect(result.structureMap?.name).toBe('ComprehensiveMap');
+ expect(result.structureMap?.group).toHaveLength(1);
+ expect(result.structureMap?.group[0].name).toBe('main');
+ });
+
+ test('should handle nested braces in conceptmap declarations', () => {
+ const fmlWithNestedBraces = `
+ map "http://example.org/nested" = "NestedMap"
+ conceptmap "http://example.org/complex" {
+ target "http://terminology.hl7.org/CodeSystem/observation-category"
+ group MyGroup {
+ element[0] {
+ target.code = "survey"
+ target.display = "Survey"
+ }
+ }
+ }
+
+ group main(source : Patient) {
+ name : source.name -> target.name;
+ }
+ `;
+
+ const result = compiler.compile(fmlWithNestedBraces);
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.url).toBe('http://example.org/nested');
+ expect(result.structureMap?.name).toBe('NestedMap');
+ });
+
+ test('should handle mixed comment types', () => {
+ const fmlWithMixedComments = `
+ /* Multi-line comment at the start */
+ /// Documentation comment
+ map "http://example.org/mixed" = "MixedComments"
+
+ // Single line comment
+ /* Another multi-line
+ comment block */
+
+ group main(source : Patient) {
+ /// Documentation for this rule
+ name : source.name -> target.name; // Inline comment
+ }
+ `;
+
+ const result = compiler.compile(fmlWithMixedComments);
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.url).toBe('http://example.org/mixed');
+ expect(result.structureMap?.name).toBe('MixedComments');
+ });
+});
\ No newline at end of file
diff --git a/tests/fhir-mapping-language.test.ts b/tests/fhir-mapping-language.test.ts
new file mode 100644
index 0000000..c96deec
--- /dev/null
+++ b/tests/fhir-mapping-language.test.ts
@@ -0,0 +1,340 @@
+import { FmlRunner } from '../src/index';
+import { FmlCompiler } from '../src/lib/fml-compiler';
+import { StructureMapExecutor } from '../src/lib/structure-map-executor';
+import { StructureMapRetriever } from '../src/lib/structure-map-retriever';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+describe('FHIR Mapping Language Tests (Matchbox-style)', () => {
+ let fmlRunner: FmlRunner;
+ let compiler: FmlCompiler;
+ let executor: StructureMapExecutor;
+ let retriever: StructureMapRetriever;
+
+ beforeAll(() => {
+ fmlRunner = new FmlRunner({ baseUrl: './tests/mapping-language' });
+ compiler = new FmlCompiler();
+ executor = new StructureMapExecutor();
+ retriever = new StructureMapRetriever();
+ retriever.setBaseDirectory('./tests/mapping-language');
+ });
+
+ // Helper function to load file content
+ function getFileAsString(relativePath: string): string {
+ const fullPath = join(__dirname, 'mapping-language', relativePath);
+ return readFileSync(fullPath, 'utf-8');
+ }
+
+ describe('Basic FML Compilation Tests', () => {
+ test('testQr2PatientCompilation', () => {
+ // Load and compile the mapping
+ const mapContent = getFileAsString('/maps/qr2patgender.map');
+ const compilationResult = compiler.compile(mapContent);
+
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.resourceType).toBe('StructureMap');
+ expect(compilationResult.structureMap!.url).toBe('http://ahdis.ch/matchbox/fml/qr2patgender');
+ expect(compilationResult.structureMap!.name).toBe('qr2patgender');
+ expect(compilationResult.structureMap!.group).toBeTruthy();
+ expect(compilationResult.structureMap!.group.length).toBeGreaterThan(0);
+ });
+
+ test('testMemberOfCompilation', () => {
+ const mapContent = getFileAsString('/maps/memberof.map');
+ const compilationResult = compiler.compile(mapContent);
+
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.url).toBe('http://ahdis.ch/matchbox/fml/memberof');
+ expect(compilationResult.structureMap!.name).toBe('memberof');
+ });
+
+ test('testNarrativeCompilation', () => {
+ const mapContent = getFileAsString('/maps/narrative.map');
+ const compilationResult = compiler.compile(mapContent);
+
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.url).toBe('http://ahdis.ch/matchbox/fml/narrative');
+ });
+
+ test('testStringToCodingCompilation', () => {
+ const mapContent = getFileAsString('/maps/stringtocoding.map');
+ const compilationResult = compiler.compile(mapContent);
+
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.url).toBe('http://ahdis.ch/matchbox/fml/stringtocoding');
+ });
+ });
+
+ describe('Basic Execution Tests', () => {
+ test('testBasicExecution', async () => {
+ // Load the mapping
+ const mapContent = getFileAsString('/maps/qr2patgender.map');
+ const compilationResult = compiler.compile(mapContent);
+ expect(compilationResult.success).toBe(true);
+
+ // Load the source data
+ const sourceData = getFileAsString('/data/qr.json');
+ const sourceObj = JSON.parse(sourceData);
+
+ // Execute transformation - with current basic implementation
+ const result = await executor.execute(compilationResult.structureMap!, sourceObj);
+ expect(result.success).toBe(true);
+ expect(result.result).toBeTruthy();
+ // Note: Current implementation returns basic structure, not full transformation
+ });
+
+ test('testExecutionWithValidation', async () => {
+ const mapContent = getFileAsString('/maps/qr2patgender.map');
+ const compilationResult = compiler.compile(mapContent);
+ expect(compilationResult.success).toBe(true);
+
+ const sourceData = getFileAsString('/data/qr.json');
+ const sourceObj = JSON.parse(sourceData);
+
+ // Execute with validation options
+ const result = await executor.execute(compilationResult.structureMap!, sourceObj, {
+ strictMode: false,
+ validateInput: false,
+ validateOutput: false
+ });
+
+ expect(result.success).toBe(true);
+ expect(result.validation).toBeTruthy();
+ });
+ });
+
+ describe('Integration with FmlRunner', () => {
+ test('compile through FmlRunner', () => {
+ const mapContent = getFileAsString('/maps/qr2patgender.map');
+ const compilationResult = fmlRunner.compileFml(mapContent);
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ });
+
+ test('test retriever loading compiled maps', async () => {
+ // Try to load compiled StructureMap JSON file
+ const structureMap = await retriever.getStructureMap('compiled/qr2patgender.json');
+ expect(structureMap).toBeTruthy();
+ if (structureMap) {
+ expect(structureMap.url).toBe('http://ahdis.ch/matchbox/fml/qr2patgender');
+ expect(structureMap.resourceType).toBe('StructureMap');
+ }
+ });
+ });
+
+ describe('Error Handling Tests', () => {
+ test('testParseFailWithError', () => {
+ const invalidMapContent = `
+ invalid syntax here
+ map without proper structure
+ missing quotes and format
+ `;
+
+ const compilationResult = compiler.compile(invalidMapContent);
+ // Current implementation is basic, but should at least not crash
+ expect(compilationResult).toBeTruthy();
+ expect(compilationResult.success).toBeDefined();
+ });
+
+ test('testExecutionWithEmptyInput', async () => {
+ const mapContent = getFileAsString('/maps/qr2patgender.map');
+ const compilationResult = compiler.compile(mapContent);
+ expect(compilationResult.success).toBe(true);
+
+ // Try to execute with empty source
+ const result = await executor.execute(compilationResult.structureMap!, {});
+ expect(result).toBeTruthy();
+ expect(result.success).toBeDefined();
+ });
+
+ test('testExecutionWithNullStructureMap', async () => {
+ const result = await executor.execute(null as any, {});
+ expect(result.success).toBe(false);
+ expect(result.errors).toBeTruthy();
+ expect(result.errors![0]).toContain('StructureMap is required');
+ });
+ });
+
+ describe('Advanced Compilation Features', () => {
+ test('Date Manipulation Compilation', () => {
+ const dateMapContent = `
+ map "http://ahdis.ch/matchbox/fml/qr2patfordates" = "qr2patfordates"
+
+ uses "http://hl7.org/fhir/StructureDefinition/QuestionnaireResponse" alias QuestionnaireResponse as source
+ uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as target
+
+ group qr2pat(source src : QuestionnaireResponse, target tgt : Patient) {
+ src -> tgt.birthDate = '2023-10-26' "birthDate";
+ src -> tgt.deceased = '2023-09-20T13:19:13.502Z' "deceased";
+ }
+ `;
+
+ const compilationResult = compiler.compile(dateMapContent);
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.url).toBe('http://ahdis.ch/matchbox/fml/qr2patfordates');
+ });
+
+ test('Bundle Mapping Compilation', () => {
+ const bundleMapContent = `
+ map "http://test.ch/DummyBundleToBundle" = "bundleTest"
+
+ uses "http://hl7.org/fhir/StructureDefinition/Bundle" alias Bundle as source
+ uses "http://hl7.org/fhir/StructureDefinition/Bundle" alias Bundle as target
+
+ group bundle2bundle(source src : Bundle, target tgt : Bundle) {
+ src.type -> tgt.type;
+ src.entry -> tgt.entry;
+ }
+ `;
+
+ const compilationResult = compiler.compile(bundleMapContent);
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.url).toBe('http://test.ch/DummyBundleToBundle');
+ expect(compilationResult.structureMap!.name).toBe('bundleTest');
+ });
+
+ test('Conditional Mapping Compilation', () => {
+ const conditionalMapContent = `
+ map "http://ahdis.ch/matchbox/fml/whereclause" = "whereclause"
+
+ uses "http://hl7.org/fhir/StructureDefinition/CapabilityStatement" alias CapabilityStatement as source
+ uses "http://hl7.org/fhir/StructureDefinition/CapabilityStatement" alias CapabilityStatement as target
+
+ group cap2cap(source src : CapabilityStatement, target tgt : CapabilityStatement) {
+ src.rest as rest -> tgt.rest = rest then {
+ rest.resource as resource -> tgt.rest.resource = resource then {
+ resource.interaction as interaction where type = 'read' -> tgt.rest.resource.interaction = interaction;
+ };
+ };
+ }
+ `;
+
+ const compilationResult = compiler.compile(conditionalMapContent);
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.url).toBe('http://ahdis.ch/matchbox/fml/whereclause');
+ });
+ });
+
+ describe('Performance and Data Handling Tests', () => {
+ test('Large FML Content Compilation', () => {
+ // Create a large FML content with many rules
+ let largeFmlContent = `
+ map "http://example.org/large-map" = "largeMap"
+
+ uses "http://hl7.org/fhir/StructureDefinition/Bundle" alias Bundle as source
+ uses "http://hl7.org/fhir/StructureDefinition/Bundle" alias Bundle as target
+
+ group bundle2bundle(source src : Bundle, target tgt : Bundle) {
+ src.type -> tgt.type;
+ `;
+
+ // Add many transformation rules
+ for (let i = 0; i < 100; i++) {
+ largeFmlContent += `\n src.entry${i} -> tgt.entry${i};`;
+ }
+ largeFmlContent += '\n }';
+
+ const startTime = Date.now();
+ const compilationResult = compiler.compile(largeFmlContent);
+ const endTime = Date.now();
+
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+
+ const compilationTime = endTime - startTime;
+ console.log(`Large FML compilation took ${compilationTime}ms for 100+ rules`);
+ expect(compilationTime).toBeLessThan(1000); // Should compile within 1 second
+ });
+
+ test('Memory usage with large StructureMap', async () => {
+ const mapContent = getFileAsString('/maps/qr2patgender.map');
+
+ // Compile multiple times to test memory usage
+ const startMemory = process.memoryUsage().heapUsed;
+
+ for (let i = 0; i < 100; i++) {
+ const compilationResult = compiler.compile(mapContent);
+ expect(compilationResult.success).toBe(true);
+ }
+
+ const endMemory = process.memoryUsage().heapUsed;
+ const memoryIncrease = endMemory - startMemory;
+
+ console.log(`Memory increase after 100 compilations: ${memoryIncrease / 1024 / 1024} MB`);
+ // Should not increase memory dramatically
+ expect(memoryIncrease).toBeLessThan(50 * 1024 * 1024); // Less than 50MB increase
+ });
+ });
+
+ describe('Tutorial-style Tests', () => {
+ test('Tutorial Step 1 - Basic mapping compilation', () => {
+ const tutorialContent = getFileAsString('/tutorial/step1/map/step1.map');
+ const compilationResult = compiler.compile(tutorialContent);
+
+ expect(compilationResult.success).toBe(true);
+ expect(compilationResult.structureMap).toBeTruthy();
+ expect(compilationResult.structureMap!.url).toBe('http://hl7.org/fhir/StructureMap/tutorial-step1');
+ expect(compilationResult.structureMap!.name).toBe('tutorial-step1');
+ });
+
+ test('Tutorial Step 1 - Basic execution', async () => {
+ const tutorialContent = getFileAsString('/tutorial/step1/map/step1.map');
+ const compilationResult = compiler.compile(tutorialContent);
+ expect(compilationResult.success).toBe(true);
+
+ const sourceData = getFileAsString('/tutorial/step1/source/source1.json');
+ const sourceObj = JSON.parse(sourceData);
+
+ const result = await executor.execute(compilationResult.structureMap!, sourceObj);
+ expect(result.success).toBe(true);
+ expect(result.result).toBeTruthy();
+ });
+ });
+
+ describe('Validation Service Integration', () => {
+ test('Get validation service', () => {
+ const validationService = executor.getValidationService();
+ expect(validationService).toBeTruthy();
+ });
+
+ test('Execute with validation service', async () => {
+ const mapContent = getFileAsString('/maps/qr2patgender.map');
+ const compilationResult = compiler.compile(mapContent);
+ expect(compilationResult.success).toBe(true);
+
+ const sourceData = getFileAsString('/data/qr.json');
+ const sourceObj = JSON.parse(sourceData);
+
+ // Register a basic StructureDefinition
+ const validationService = executor.getValidationService();
+ const basicStructureDefinition = {
+ resourceType: 'StructureDefinition' as const,
+ url: 'http://example.org/test',
+ name: 'TestStructure',
+ status: 'active' as const,
+ kind: 'logical' as const,
+ type: 'Test',
+ differential: {
+ element: [
+ {
+ path: 'Test',
+ id: 'Test'
+ }
+ ]
+ }
+ };
+
+ validationService.registerStructureDefinition(basicStructureDefinition);
+
+ const result = await executor.execute(compilationResult.structureMap!, sourceObj);
+ expect(result.success).toBe(true);
+ });
+ });
+});
\ No newline at end of file
diff --git a/tests/fhirpath-integration.test.ts b/tests/fhirpath-integration.test.ts
new file mode 100644
index 0000000..3107c00
--- /dev/null
+++ b/tests/fhirpath-integration.test.ts
@@ -0,0 +1,108 @@
+import { StructureMapExecutor } from '../src/lib/structure-map-executor';
+import { StructureMap } from '../src/types';
+
+describe('FHIRPath Integration', () => {
+ let executor: StructureMapExecutor;
+
+ beforeEach(() => {
+ executor = new StructureMapExecutor();
+ });
+
+ test('should use proper FHIRPath evaluation for simple expressions', () => {
+ const structureMap: StructureMap = {
+ resourceType: 'StructureMap',
+ id: 'test-fhirpath',
+ name: 'TestFHIRPath',
+ url: 'http://example.com/StructureMap/test-fhirpath',
+ status: 'draft',
+ group: [{
+ name: 'main',
+ input: [{ name: 'source', mode: 'source' }],
+ rule: [{
+ name: 'test-evaluate',
+ source: [{ element: 'name', context: 'source' }],
+ target: [{
+ element: 'result',
+ transform: 'evaluate',
+ parameter: ['first().given.first()']
+ }]
+ }]
+ }]
+ };
+
+ const inputData = {
+ name: [{
+ given: ['John', 'Middle'],
+ family: 'Doe'
+ }]
+ };
+
+ const result = executor.execute(structureMap, inputData);
+
+ expect(result.success).toBe(true);
+ expect(result.result).toHaveProperty('result');
+ expect(result.result.result).toBe('John'); // Should extract first given name
+ });
+
+ test('should handle FHIRPath evaluation errors gracefully', () => {
+ const structureMap: StructureMap = {
+ resourceType: 'StructureMap',
+ id: 'test-fhirpath-error',
+ name: 'TestFHIRPathError',
+ url: 'http://example.com/StructureMap/test-fhirpath-error',
+ status: 'draft',
+ group: [{
+ name: 'main',
+ input: [{ name: 'source', mode: 'source' }],
+ rule: [{
+ name: 'test-evaluate-error',
+ source: [{ element: 'data', context: 'source' }],
+ target: [{
+ element: 'result',
+ transform: 'evaluate',
+ parameter: ['invalid FHIRPath syntax...']
+ }]
+ }]
+ }]
+ };
+
+ const inputData = { data: 'test' };
+
+ const result = executor.execute(structureMap, inputData);
+
+ expect(result.success).toBe(true);
+ expect(result.result).toHaveProperty('result');
+ expect(result.result.result).toBeUndefined(); // Should return undefined for failed evaluations
+ });
+
+ test('should work with boolean expressions', () => {
+ const structureMap: StructureMap = {
+ resourceType: 'StructureMap',
+ id: 'test-boolean',
+ name: 'TestBoolean',
+ url: 'http://example.com/StructureMap/test-boolean',
+ status: 'draft',
+ group: [{
+ name: 'main',
+ input: [{ name: 'source', mode: 'source' }],
+ rule: [{
+ name: 'test-boolean',
+ source: [{ element: 'active', context: 'source' }],
+ target: [{
+ element: 'isActive',
+ transform: 'evaluate',
+ parameter: ['true']
+ }]
+ }]
+ }]
+ };
+
+ const inputData = { active: true };
+
+ const result = executor.execute(structureMap, inputData);
+
+ expect(result.success).toBe(true);
+ expect(result.result).toHaveProperty('isActive');
+ expect(result.result.isActive).toBe(true);
+ });
+});
\ No newline at end of file
diff --git a/tests/fml-compiler.test.ts b/tests/fml-compiler.test.ts
new file mode 100644
index 0000000..d1fa14f
--- /dev/null
+++ b/tests/fml-compiler.test.ts
@@ -0,0 +1,55 @@
+import { FmlCompiler } from '../src/lib/fml-compiler';
+
+describe('FmlCompiler', () => {
+ let compiler: FmlCompiler;
+
+ beforeEach(() => {
+ compiler = new FmlCompiler();
+ });
+
+ describe('compile', () => {
+ it('should reject empty FML content', () => {
+ const result = compiler.compile('');
+ expect(result.success).toBe(false);
+ expect(result.errors).toContain('FML content cannot be empty');
+ });
+
+ it('should reject whitespace-only FML content', () => {
+ const result = compiler.compile(' \n \t ');
+ expect(result.success).toBe(false);
+ expect(result.errors).toContain('FML content cannot be empty');
+ });
+
+ it('should compile basic FML to StructureMap', () => {
+ const fmlContent = `
+ map "http://example.org/StructureMap/test" = "TestMap"
+
+ source -> target
+ `;
+
+ const result = compiler.compile(fmlContent);
+ expect(result.success).toBe(true);
+ expect(result.structureMap).toBeDefined();
+ expect(result.structureMap?.resourceType).toBe('StructureMap');
+ expect(result.structureMap?.name).toBe('TestMap');
+ expect(result.structureMap?.url).toBe('http://example.org/StructureMap/test');
+ });
+
+ it('should handle compilation errors gracefully', () => {
+ // Test with malformed content that should trigger an error
+ const result = compiler.compile('invalid fml content');
+ expect(result.success).toBe(true); // Enhanced parser should handle this gracefully with fallback
+ expect(result.structureMap).toBeDefined();
+ expect(result.structureMap?.name).toBe('DefaultMap'); // Should use fallback
+ });
+
+ it('should create default structure when no map declaration found', () => {
+ const fmlContent = 'some -> mapping';
+ const result = compiler.compile(fmlContent);
+
+ expect(result.success).toBe(true);
+ expect(result.structureMap?.name).toBe('DefaultMap');
+ expect(result.structureMap?.url).toContain('DefaultMap');
+ });
+ });
+});
\ No newline at end of file
diff --git a/tests/fml-runner.test.ts b/tests/fml-runner.test.ts
new file mode 100644
index 0000000..7991567
--- /dev/null
+++ b/tests/fml-runner.test.ts
@@ -0,0 +1,73 @@
+import { FmlRunner } from '../src';
+import * as path from 'path';
+
+describe('FmlRunner', () => {
+ let runner: FmlRunner;
+ const testDataDir = path.join(__dirname, 'test-data');
+
+ beforeEach(() => {
+ runner = new FmlRunner({ baseUrl: testDataDir });
+ });
+
+ describe('compileFml', () => {
+ it('should compile valid FML content', () => {
+ const fmlContent = `
+ map "http://example.org/StructureMap/test" = "TestMap"
+ source -> target
+ `;
+
+ const result = runner.compileFml(fmlContent);
+ expect(result.success).toBe(true);
+ expect(result.structureMap).toBeDefined();
+ });
+
+ it('should reject empty FML content', () => {
+ const result = runner.compileFml('');
+ expect(result.success).toBe(false);
+ expect(result.errors).toBeDefined();
+ });
+ });
+
+ describe('executeStructureMap', () => {
+ it('should execute StructureMap from file', async () => {
+ const inputData = { name: 'John Doe' };
+ const result = await runner.executeStructureMap('test-structure-map.json', inputData);
+
+ expect(result.success).toBe(true);
+ expect(result.result).toEqual({ fullName: 'John Doe' });
+ });
+
+ it('should return error for non-existent StructureMap', async () => {
+ const result = await runner.executeStructureMap('non-existent.json', {});
+ expect(result.success).toBe(false);
+ expect(result.errors?.[0]).toContain('StructureMap not found');
+ });
+ });
+
+ describe('getStructureMap', () => {
+ it('should retrieve StructureMap from file', async () => {
+ const structureMap = await runner.getStructureMap('test-structure-map.json');
+ expect(structureMap).toBeDefined();
+ expect(structureMap?.resourceType).toBe('StructureMap');
+ expect(structureMap?.name).toBe('TestMap');
+ });
+
+ it('should return null for non-existent file', async () => {
+ const result = await runner.getStructureMap('non-existent.json');
+ expect(result).toBeNull();
+ });
+ });
+
+ describe('clearCache', () => {
+ it('should clear cache without errors', () => {
+ expect(() => runner.clearCache()).not.toThrow();
+ });
+ });
+
+ describe('setBaseDirectory', () => {
+ it('should update base directory', () => {
+ const newDir = '/new/path';
+ expect(() => runner.setBaseDirectory(newDir)).not.toThrow();
+ });
+ });
+});
\ No newline at end of file
diff --git a/tests/mapping-language/compiled/qr2patgender.json b/tests/mapping-language/compiled/qr2patgender.json
new file mode 100644
index 0000000..72dc92b
--- /dev/null
+++ b/tests/mapping-language/compiled/qr2patgender.json
@@ -0,0 +1,46 @@
+{
+ "resourceType": "StructureMap",
+ "url": "http://ahdis.ch/matchbox/fml/qr2patgender",
+ "name": "qr2patgender",
+ "status": "draft",
+ "group": [
+ {
+ "name": "main",
+ "input": [
+ {
+ "name": "source",
+ "mode": "source"
+ },
+ {
+ "name": "target",
+ "mode": "target"
+ }
+ ],
+ "rule": [
+ {
+ "name": "rule1",
+ "source": [
+ {
+ "context": "source",
+ "element": "item",
+ "variable": "item",
+ "condition": "linkId = 'gender'"
+ }
+ ],
+ "target": [
+ {
+ "context": "target",
+ "element": "gender",
+ "transform": "copy",
+ "parameter": [
+ {
+ "valueString": "item.answer.valueString"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/tests/mapping-language/data/capabilitystatement-example.json b/tests/mapping-language/data/capabilitystatement-example.json
new file mode 100644
index 0000000..5316a47
--- /dev/null
+++ b/tests/mapping-language/data/capabilitystatement-example.json
@@ -0,0 +1,23 @@
+{
+ "resourceType": "CapabilityStatement",
+ "id": "example",
+ "status": "active",
+ "date": "2023-01-01",
+ "rest": [
+ {
+ "mode": "server",
+ "resource": [
+ {
+ "type": "Patient",
+ "interaction": [
+ { "code": "read" },
+ { "code": "search-type" },
+ { "code": "create" },
+ { "code": "update" },
+ { "code": "delete" }
+ ]
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/tests/mapping-language/data/pat.json b/tests/mapping-language/data/pat.json
new file mode 100644
index 0000000..10fb44e
--- /dev/null
+++ b/tests/mapping-language/data/pat.json
@@ -0,0 +1,11 @@
+{
+ "resourceType": "Patient",
+ "id": "pat-1",
+ "gender": "male",
+ "name": [
+ {
+ "family": "Doe",
+ "given": ["John"]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/tests/mapping-language/data/qr.json b/tests/mapping-language/data/qr.json
new file mode 100644
index 0000000..59df4b4
--- /dev/null
+++ b/tests/mapping-language/data/qr.json
@@ -0,0 +1,15 @@
+{
+ "resourceType": "QuestionnaireResponse",
+ "id": "qr-1",
+ "status": "completed",
+ "item": [
+ {
+ "linkId": "gender",
+ "answer": [
+ {
+ "valueString": "female"
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/tests/mapping-language/data/qrext.json b/tests/mapping-language/data/qrext.json
new file mode 100644
index 0000000..937bdba
--- /dev/null
+++ b/tests/mapping-language/data/qrext.json
@@ -0,0 +1,28 @@
+{
+ "resourceType": "QuestionnaireResponse",
+ "id": "qr-ext-1",
+ "status": "completed",
+ "item": [
+ {
+ "linkId": "weight",
+ "answer": [
+ {
+ "valueQuantity": {
+ "value": 90,
+ "unit": "kg",
+ "system": "http://unit.org",
+ "code": "kg"
+ }
+ }
+ ]
+ },
+ {
+ "linkId": "gender",
+ "answer": [
+ {
+ "valueString": "male"
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/tests/mapping-language/maps/memberof.map b/tests/mapping-language/maps/memberof.map
new file mode 100644
index 0000000..f3f4990
--- /dev/null
+++ b/tests/mapping-language/maps/memberof.map
@@ -0,0 +1,8 @@
+map "http://ahdis.ch/matchbox/fml/memberof" = "memberof"
+
+uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as source
+uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as target
+
+group pat2pat(source src : Patient, target tgt : Patient) {
+ src.gender as gender where gender.memberOf('http://hl7.org/fhir/ValueSet/administrative-gender') -> tgt.gender = gender "rule1";
+}
\ No newline at end of file
diff --git a/tests/mapping-language/maps/narrative.map b/tests/mapping-language/maps/narrative.map
new file mode 100644
index 0000000..e041b0b
--- /dev/null
+++ b/tests/mapping-language/maps/narrative.map
@@ -0,0 +1,11 @@
+map "http://ahdis.ch/matchbox/fml/narrative" = "narrative"
+
+uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as source
+uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as target
+
+group pat2pat(source src : Patient, target tgt : Patient) {
+ src -> tgt.text = create('Narrative') as narrative then {
+ src -> narrative.status = 'generated' "status";
+ src -> narrative.div = 'text
' "div";
+ } "narrative";
+}
\ No newline at end of file
diff --git a/tests/mapping-language/maps/qr2patgender.map b/tests/mapping-language/maps/qr2patgender.map
new file mode 100644
index 0000000..eb1ad8c
--- /dev/null
+++ b/tests/mapping-language/maps/qr2patgender.map
@@ -0,0 +1,8 @@
+map "http://ahdis.ch/matchbox/fml/qr2patgender" = "qr2patgender"
+
+uses "http://hl7.org/fhir/StructureDefinition/QuestionnaireResponse" alias QuestionnaireResponse as source
+uses "http://hl7.org/fhir/StructureDefinition/Patient" alias Patient as target
+
+group qr2pat(source src : QuestionnaireResponse, target tgt : Patient) {
+ src.item as item where linkId = 'gender' -> tgt.gender = (item.answer.valueString) "rule1";
+}
\ No newline at end of file
diff --git a/tests/mapping-language/maps/stringtocoding.map b/tests/mapping-language/maps/stringtocoding.map
new file mode 100644
index 0000000..603a1d3
--- /dev/null
+++ b/tests/mapping-language/maps/stringtocoding.map
@@ -0,0 +1,8 @@
+map "http://ahdis.ch/matchbox/fml/stringtocoding" = "stringtocoding"
+
+uses "http://hl7.org/fhir/StructureDefinition/QuestionnaireResponse" alias QuestionnaireResponse as source
+uses "http://hl7.org/fhir/StructureDefinition/ExplanationOfBenefit" alias ExplanationOfBenefit as target
+
+group qr2eob(source src : QuestionnaireResponse, target tgt : ExplanationOfBenefit) {
+ src -> tgt.type = cc('http://terminology.hl7.org/CodeSystem/claim-type', 'oral') "type";
+}
\ No newline at end of file
diff --git a/tests/mapping-language/tutorial/step1/logical/structuredefinition-tleft.json b/tests/mapping-language/tutorial/step1/logical/structuredefinition-tleft.json
new file mode 100644
index 0000000..055c9ff
--- /dev/null
+++ b/tests/mapping-language/tutorial/step1/logical/structuredefinition-tleft.json
@@ -0,0 +1,33 @@
+{
+ "resourceType": "StructureDefinition",
+ "id": "tutorial-left-1",
+ "url": "http://hl7.org/fhir/StructureDefinition/tutorial-left-1",
+ "version": "5.0.0",
+ "name": "TutorialLeft1",
+ "status": "active",
+ "kind": "logical",
+ "abstract": false,
+ "type": "TLeft",
+ "baseDefinition": "http://hl7.org/fhir/StructureDefinition/Base",
+ "derivation": "specialization",
+ "differential": {
+ "element": [
+ {
+ "id": "TLeft",
+ "path": "TLeft",
+ "definition": "Tutorial Left Structure Step 1"
+ },
+ {
+ "id": "TLeft.a",
+ "path": "TLeft.a",
+ "min": 0,
+ "max": "1",
+ "type": [
+ {
+ "code": "string"
+ }
+ ]
+ }
+ ]
+ }
+}
\ No newline at end of file
diff --git a/tests/mapping-language/tutorial/step1/logical/structuredefinition-tright.json b/tests/mapping-language/tutorial/step1/logical/structuredefinition-tright.json
new file mode 100644
index 0000000..c1ed1e4
--- /dev/null
+++ b/tests/mapping-language/tutorial/step1/logical/structuredefinition-tright.json
@@ -0,0 +1,33 @@
+{
+ "resourceType": "StructureDefinition",
+ "id": "tutorial-right-1",
+ "url": "http://hl7.org/fhir/StructureDefinition/tutorial-right-1",
+ "version": "5.0.0",
+ "name": "TutorialRight1",
+ "status": "active",
+ "kind": "logical",
+ "abstract": false,
+ "type": "TRight",
+ "baseDefinition": "http://hl7.org/fhir/StructureDefinition/Base",
+ "derivation": "specialization",
+ "differential": {
+ "element": [
+ {
+ "id": "TRight",
+ "path": "TRight",
+ "definition": "Tutorial Right Structure Step 1"
+ },
+ {
+ "id": "TRight.a",
+ "path": "TRight.a",
+ "min": 0,
+ "max": "1",
+ "type": [
+ {
+ "code": "string"
+ }
+ ]
+ }
+ ]
+ }
+}
\ No newline at end of file
diff --git a/tests/mapping-language/tutorial/step1/map/step1.map b/tests/mapping-language/tutorial/step1/map/step1.map
new file mode 100644
index 0000000..d5c4ccb
--- /dev/null
+++ b/tests/mapping-language/tutorial/step1/map/step1.map
@@ -0,0 +1,8 @@
+map "http://hl7.org/fhir/StructureMap/tutorial-step1" = "tutorial-step1"
+
+uses "http://hl7.org/fhir/StructureDefinition/tutorial-left-1" alias TLeft as source
+uses "http://hl7.org/fhir/StructureDefinition/tutorial-right-1" alias TRight as target
+
+group tutorial(source src : TLeft, target tgt : TRight) {
+ src.a -> tgt.a;
+}
\ No newline at end of file
diff --git a/tests/mapping-language/tutorial/step1/result/step1.source1.json b/tests/mapping-language/tutorial/step1/result/step1.source1.json
new file mode 100644
index 0000000..b2469b6
--- /dev/null
+++ b/tests/mapping-language/tutorial/step1/result/step1.source1.json
@@ -0,0 +1,3 @@
+{
+ "a": "hello"
+}
\ No newline at end of file
diff --git a/tests/mapping-language/tutorial/step1/source/source1.json b/tests/mapping-language/tutorial/step1/source/source1.json
new file mode 100644
index 0000000..b2469b6
--- /dev/null
+++ b/tests/mapping-language/tutorial/step1/source/source1.json
@@ -0,0 +1,3 @@
+{
+ "a": "hello"
+}
\ No newline at end of file
diff --git a/tests/structure-map-executor.test.ts b/tests/structure-map-executor.test.ts
new file mode 100644
index 0000000..2b44522
--- /dev/null
+++ b/tests/structure-map-executor.test.ts
@@ -0,0 +1,92 @@
+import { StructureMapExecutor } from '../src/lib/structure-map-executor';
+import { StructureMap } from '../src/types';
+
+describe('StructureMapExecutor', () => {
+ let executor: StructureMapExecutor;
+
+ beforeEach(() => {
+ executor = new StructureMapExecutor();
+ });
+
+ const testStructureMap: StructureMap = {
+ resourceType: 'StructureMap',
+ name: 'TestMap',
+ status: 'active',
+ group: [
+ {
+ name: 'main',
+ input: [
+ { name: 'source', mode: 'source' },
+ { name: 'target', mode: 'target' }
+ ],
+ rule: [
+ {
+ source: [{ context: 'source', element: 'name' }],
+ target: [{ context: 'target', element: 'fullName' }]
+ }
+ ]
+ }
+ ]
+ };
+
+ describe('execute', () => {
+ it('should execute basic StructureMap transformation', () => {
+ const inputData = { name: 'John Doe' };
+ const result = executor.execute(testStructureMap, inputData);
+
+ expect(result.success).toBe(true);
+ expect(result.result).toEqual({ fullName: 'John Doe' });
+ });
+
+ it('should return error for null StructureMap', () => {
+ const result = executor.execute(null as any, {});
+
+ expect(result.success).toBe(false);
+ expect(result.errors).toContain('StructureMap is required');
+ });
+
+ it('should return error for StructureMap without groups', () => {
+ const invalidMap: StructureMap = {
+ resourceType: 'StructureMap',
+ name: 'Invalid',
+ status: 'active',
+ group: []
+ };
+
+ const result = executor.execute(invalidMap, {});
+
+ expect(result.success).toBe(false);
+ expect(result.errors).toContain('StructureMap must have at least one group');
+ });
+ });
+
+ describe('validateStructureMap', () => {
+ it('should validate correct StructureMap', () => {
+ const validation = executor.validateStructureMap(testStructureMap);
+ expect(validation.valid).toBe(true);
+ expect(validation.errors).toHaveLength(0);
+ });
+
+ it('should reject null StructureMap', () => {
+ const validation = executor.validateStructureMap(null as any);
+ expect(validation.valid).toBe(false);
+ expect(validation.errors).toContain('StructureMap is null or undefined');
+ });
+
+ it('should reject StructureMap with wrong resourceType', () => {
+ const invalidMap = { ...testStructureMap, resourceType: 'Patient' as any };
+ const validation = executor.validateStructureMap(invalidMap);
+
+ expect(validation.valid).toBe(false);
+ expect(validation.errors).toContain('Resource type must be "StructureMap"');
+ });
+
+ it('should reject StructureMap without groups', () => {
+ const invalidMap = { ...testStructureMap, group: [] };
+ const validation = executor.validateStructureMap(invalidMap);
+
+ expect(validation.valid).toBe(false);
+ expect(validation.errors).toContain('StructureMap must have at least one group');
+ });
+ });
+});
\ No newline at end of file
diff --git a/tests/structure-map-retriever.test.ts b/tests/structure-map-retriever.test.ts
new file mode 100644
index 0000000..dd46010
--- /dev/null
+++ b/tests/structure-map-retriever.test.ts
@@ -0,0 +1,53 @@
+import { StructureMapRetriever } from '../src/lib/structure-map-retriever';
+import * as path from 'path';
+
+describe('StructureMapRetriever', () => {
+ let retriever: StructureMapRetriever;
+ const testDataDir = path.join(__dirname, 'test-data');
+
+ beforeEach(() => {
+ retriever = new StructureMapRetriever(testDataDir);
+ });
+
+ describe('getStructureMap', () => {
+ it('should load StructureMap from file', async () => {
+ const structureMap = await retriever.getStructureMap('test-structure-map.json');
+
+ expect(structureMap).toBeDefined();
+ expect(structureMap?.resourceType).toBe('StructureMap');
+ expect(structureMap?.name).toBe('TestMap');
+ expect(structureMap?.url).toBe('http://example.org/StructureMap/test');
+ });
+
+ it('should return null for non-existent file', async () => {
+ const structureMap = await retriever.getStructureMap('non-existent.json');
+ expect(structureMap).toBeNull();
+ });
+
+ it('should cache loaded StructureMaps', async () => {
+ const structureMap1 = await retriever.getStructureMap('test-structure-map.json');
+ const structureMap2 = await retriever.getStructureMap('test-structure-map.json');
+
+ expect(structureMap1).toBe(structureMap2); // Should be same cached instance
+ });
+
+ it('should clear cache when requested', async () => {
+ await retriever.getStructureMap('test-structure-map.json');
+ retriever.clearCache();
+
+ // Should load fresh after cache clear
+ const structureMap = await retriever.getStructureMap('test-structure-map.json');
+ expect(structureMap).toBeDefined();
+ });
+ });
+
+ describe('setBaseDirectory', () => {
+ it('should update base directory', () => {
+ const newDir = '/new/path';
+ retriever.setBaseDirectory(newDir);
+ // No direct way to test this without making baseDirectory public
+ // In a real implementation, might want to add a getter
+ expect(() => retriever.setBaseDirectory(newDir)).not.toThrow();
+ });
+ });
+});
\ No newline at end of file
diff --git a/tests/test-data/test-structure-map.json b/tests/test-data/test-structure-map.json
new file mode 100644
index 0000000..94dd9db
--- /dev/null
+++ b/tests/test-data/test-structure-map.json
@@ -0,0 +1,38 @@
+{
+ "resourceType": "StructureMap",
+ "id": "test-map",
+ "url": "http://example.org/StructureMap/test",
+ "name": "TestMap",
+ "status": "active",
+ "group": [
+ {
+ "name": "main",
+ "input": [
+ {
+ "name": "source",
+ "mode": "source"
+ },
+ {
+ "name": "target",
+ "mode": "target"
+ }
+ ],
+ "rule": [
+ {
+ "source": [
+ {
+ "context": "source",
+ "element": "name"
+ }
+ ],
+ "target": [
+ {
+ "context": "target",
+ "element": "fullName"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/tests/validation-service.test.ts b/tests/validation-service.test.ts
new file mode 100644
index 0000000..2aa26c1
--- /dev/null
+++ b/tests/validation-service.test.ts
@@ -0,0 +1,167 @@
+import { ValidationService } from '../src/lib/validation-service';
+import { StructureDefinition } from '../src/types';
+
+describe('ValidationService', () => {
+ let validationService: ValidationService;
+
+ beforeEach(() => {
+ validationService = new ValidationService();
+ });
+
+ describe('registerStructureDefinition', () => {
+ it('should register StructureDefinition by URL', () => {
+ const structureDefinition: StructureDefinition = {
+ resourceType: 'StructureDefinition',
+ url: 'http://example.org/StructureDefinition/Patient',
+ name: 'Patient',
+ status: 'active',
+ kind: 'resource',
+ type: 'Patient'
+ };
+
+ validationService.registerStructureDefinition(structureDefinition);
+ const definitions = validationService.getStructureDefinitions();
+
+ expect(definitions.length).toBeGreaterThanOrEqual(1);
+ expect(definitions[0].name).toBe('Patient');
+ });
+
+ it('should register StructureDefinition by name', () => {
+ const structureDefinition: StructureDefinition = {
+ resourceType: 'StructureDefinition',
+ name: 'TestProfile',
+ status: 'draft',
+ kind: 'logical',
+ type: 'TestResource'
+ };
+
+ validationService.registerStructureDefinition(structureDefinition);
+ const definitions = validationService.getStructureDefinitions();
+
+ expect(definitions).toHaveLength(1);
+ expect(definitions[0].name).toBe('TestProfile');
+ });
+ });
+
+ describe('validate', () => {
+ beforeEach(() => {
+ const structureDefinition: StructureDefinition = {
+ resourceType: 'StructureDefinition',
+ url: 'http://example.org/StructureDefinition/Patient',
+ name: 'Patient',
+ status: 'active',
+ kind: 'resource',
+ type: 'Patient',
+ snapshot: {
+ element: [
+ {
+ path: 'Patient',
+ min: 1,
+ max: '1'
+ },
+ {
+ path: 'Patient.name',
+ min: 1,
+ max: '*',
+ type: [{ code: 'string' }]
+ },
+ {
+ path: 'Patient.active',
+ min: 0,
+ max: '1',
+ type: [{ code: 'boolean' }]
+ }
+ ]
+ }
+ };
+
+ validationService.registerStructureDefinition(structureDefinition);
+ });
+
+ it('should validate valid resource', () => {
+ const patient = {
+ resourceType: 'Patient',
+ name: 'John Doe',
+ active: true
+ };
+
+ const result = validationService.validate(patient, 'http://example.org/StructureDefinition/Patient');
+
+ expect(result.valid).toBe(true);
+ expect(result.errors).toHaveLength(0);
+ });
+
+ it('should detect missing required elements', () => {
+ const patient = {
+ resourceType: 'Patient',
+ active: true
+ // Missing required 'name' field
+ };
+
+ const result = validationService.validate(patient, 'http://example.org/StructureDefinition/Patient');
+
+ expect(result.valid).toBe(false);
+ expect(result.errors).toHaveLength(1);
+ expect(result.errors[0].message).toContain('Required element');
+ expect(result.errors[0].path).toBe('Patient.name');
+ });
+
+ it('should detect wrong resource type', () => {
+ const observation = {
+ resourceType: 'Observation',
+ name: 'Test'
+ };
+
+ const result = validationService.validate(observation, 'http://example.org/StructureDefinition/Patient');
+
+ expect(result.valid).toBe(false);
+ expect(result.errors).toHaveLength(1);
+ expect(result.errors[0].message).toContain('Expected resourceType');
+ });
+
+ it('should return error for unknown StructureDefinition', () => {
+ const resource = {
+ resourceType: 'Unknown'
+ };
+
+ const result = validationService.validate(resource, 'http://example.org/unknown');
+
+ expect(result.valid).toBe(false);
+ expect(result.errors).toHaveLength(1);
+ expect(result.errors[0].message).toContain('StructureDefinition not found');
+ });
+
+ it('should generate warnings for type mismatches', () => {
+ const patient = {
+ resourceType: 'Patient',
+ name: 'John Doe',
+ active: 'true' // String instead of boolean
+ };
+
+ const result = validationService.validate(patient, 'http://example.org/StructureDefinition/Patient');
+
+ expect(result.valid).toBe(true); // No errors, just warnings
+ expect(result.warnings).toHaveLength(1);
+ expect(result.warnings[0].message).toContain('may not match expected type');
+ expect(result.warnings[0].path).toBe('Patient.active');
+ });
+ });
+
+ describe('clearStructureDefinitions', () => {
+ it('should clear all registered StructureDefinitions', () => {
+ const structureDefinition: StructureDefinition = {
+ resourceType: 'StructureDefinition',
+ name: 'Test',
+ status: 'active',
+ kind: 'logical',
+ type: 'Test'
+ };
+
+ validationService.registerStructureDefinition(structureDefinition);
+ expect(validationService.getStructureDefinitions()).toHaveLength(1);
+
+ validationService.clearStructureDefinitions();
+ expect(validationService.getStructureDefinitions()).toHaveLength(0);
+ });
+ });
+});
\ No newline at end of file
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..aba4d5c
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,18 @@
+{
+ "compilerOptions": {
+ "target": "ES2020",
+ "module": "commonjs",
+ "lib": ["ES2020"],
+ "outDir": "./dist",
+ "rootDir": "./src",
+ "strict": true,
+ "esModuleInterop": true,
+ "skipLibCheck": true,
+ "forceConsistentCasingInFileNames": true,
+ "declaration": true,
+ "declarationMap": true,
+ "sourceMap": true
+ },
+ "include": ["src/**/*"],
+ "exclude": ["node_modules", "dist", "tests"]
+}
\ No newline at end of file