yini-parser 1.3.2-beta → 1.4.0-beta

package/dist/dev/quick-test-samples/valid-inputs.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Development-only YINI samples.
+ *
+ * These inputs are used for quick manual testing during development
+ * via src/dev/quick-test-samples/main.ts. They are NOT part of the automated test suite.
+ *
+ * All real testing belongs in /tests/.
+ */
+export declare const validConfigShort = "\n^ App\nname = 'Hello'\n";
+export declare const validConfigBasic = "\n^ App\nname = \"My Application\"\nversion = 1.0\nfeatures = [\"search\", \"logging\"]\n\n    // Nested sub-section under App\n    ^^ Database\n    host = \"localhost\"\n    port = 5432\n";
+export declare const validConfigWithObjects = "\n^ App\n  name = \"Demo\"\n  version = \"1.0.0\"\n  features = [ \"search\", \"dark-mode\" ]\n\n^ Database\n  host = \"localhost\"\n  port = 5432\n  auth = { user: \"admin\", pass: \"secret\" }\n";
+/**
+ * Covers booleans, nulls, number formats, and deeper nesting
+ */
+export declare const validConfigAdvanced = "\n^ Server\n  enabled = ON\n  timeout = 3.5\n  retries = 5\n  threshold = 1e-3\n  fallback = null\n\n  ^^ Logging\n     level = \"info\"\n     output = { file: \"app.log\", rotate: true }\n";
+/**
+ * Covers arrays of objects and realistic structure
+ */
+export declare const validConfigComplex = "\n^ App\n  services = [\n    { name: \"api\",  port: 8080 },\n    { name: \"web\",  port: 3000 },\n    { name: \"auth\", port: 9000 }\n  ]\n\n^ Security\n  roles = [\"admin\", \"user\", \"guest\"]\n  enabled = true\n";
+export declare const validConfigComplexBigA = "\n@YINI\n\n// Example A: Corporate SaaS Platform.\n\n^ App\nname = \"Acme Platform\"    // Example Platform\ndescription = \"The word \u201CAcme\u201D has been used for over 100 years in technical and business examples.\"\nmeaning = \"It comes from Greek akm\u1E17 (\u1F00\u03BA\u03BC\u03AE), meaning \u201Cthe highest point\u201D or \u201Cbest\u201D.\"\nversion = \"2.3.1\"\ndebug = OFF\nenvironment = \"production\"\nmaintainers = [\"ops@acme.com\", \"dev@acme.com\"]\n\n    ^^ Features\n    enableSearch = true\n    enablePayments = true\n    enableAnalytics = false\n    experimental = [\"new-ui\", \"streaming-api\"]\n\n    ^^ Limits\n    maxUsers = 50000\n    requestTimeoutMs = 3500\n    retryPolicy = { maxRetries: 5, backoff: \"exponential\" }\n\n    ^^ Database\n    engine = \"postgres\"\n    host = \"db.internal.acme.com\"\n    port = 5432\n    ssl = true\n    pool = { min: 5, max: 50 }\n\n        ^^^ Credentials\n        username = \"app_user\"\n        password = \"****\"\n        rotateEveryDays = 90\n\n    ^^ API\n    baseUrl = \"https://api.acme.com\"\n    publicEndpoints = [\"/health\", \"/status\"]\n    internalEndpoints = [\"/admin\", \"/metrics\"]\n\n        ^^^ Auth\n        provider = \"oauth2\"\n        tokenTTLSeconds = 3600\n        scopes = [\"read\", \"write\", \"admin\"]\n\n            ^^^^ Clients\n            web = { clientId: \"web-123\", redirectUri: \"https://acme.com/callback\" }\n            mobile = { clientId: \"mob-456\", redirectUri: \"acme://auth\" }\n\n^ Logging\nlevel = \"info\"\nformat = \"json\"\noutputs = [\"stdout\", \"file\"]\n\n    ^^ File\n    path = \"/var/log/acme/app.log\"\n    maxSizeMB = 100\n    rotate = true\n    keepFiles = 10\n\n    ^^ Metrics\n    enabled = true\n    endpoint = \"/metrics\"\n    sampleRate = 0.25\n\n^ Services\nenabled = true\n\n    ^^ Email\n    provider = \"smtp\"\n    host = \"smtp.acme.com\"\n    port = 587\n    secure = false\n    from = \"no-reply@acme.com\"\n\n        ^^^ Credentials\n        user = \"mailer\"\n        pass = \"mailer-secret\"\n\n    ^^ Cache\n    type = \"redis\"\n    host = \"cache.internal.acme.com\"\n    port = 6379\n    ttlSeconds = 600\n\n        ^^^ Cluster\n        nodes = [\n          { host: \"cache-1.internal\", port: 6379 },\n          { host: \"cache-2.internal\", port: 6379 },\n          { host: \"cache-3.internal\", port: 6379 }\n        ]\n\n^ Observability\ntracing = true\ntracingProvider = \"opentelemetry\"\ntraceSampleRate = 0.1\n\n    ^^ Exporters\n    jaeger = { enabled: true, endpoint: \"http://jaeger:14268/api/traces\" }\n    prometheus = { enabled: true, endpoint: \"http://prom:9090\" }\n\n^ Security\nallowedIPs = [\"10.0.0.0/8\", \"192.168.0.0/16\"]\nblockedCountries = [\"KP\", \"SD\"]\n\n    ^^ Policies\n    passwordMinLength = 14\n    require2FA = true\n    sessionTTLMinutes = 120\n\n        ^^^ Lockout\n        maxAttempts = 5\n        lockoutMinutes = 30\n";
+export declare const validConfigComplexBigB = "\n@YINI\n\n// Example B: High-Security Distributed Control System.\n\n^ App\nname = 'Nebula Control Suite'\ndescription = 'A distributed operations platform for autonomous systems and edge analytics.'\nmeaning = 'Nebula comes from Latin \"nebula\" meaning mist or cloud.'\nversion = '5.0.0-rc.4'\ndebug = ON\nenvironment = 'staging'\nmaintainers = ['infra@nebula.io', 'platform@nebula.io', 'secops@nebula.io']\n\n    ^^ Features\n    enableSearch = false\n    enablePayments = false\n    enableAnalytics = true\n    experimental = ['vector-engine', 'adaptive-ui', 'ai-routing']\n\n    ^^ Limits\n    maxUsers = 120000\n    requestTimeoutMs = 7200\n    retryPolicy = {\n        maxRetries: 9,\n        backoff: 'fibonacci',\n        retryOn: ['timeout', '5xx', 'throttle'],\n        schedule: [\n            { attempt: 1, delayMs: 80 },\n            { attempt: 2, delayMs: 160 },\n            { attempt: 3, delayMs: 320 },\n            { attempt: 4, delayMs: 640 },\n            { attempt: 5, delayMs: 1280 }\n        ]\n    }\n\n    ^^ Database\n    engine = 'cockroachdb'\n    host = 'cluster.db.nebula.io'\n    port = 26257\n    ssl = true\n    pool = {\n        min: 12,\n        max: 120,\n        warmup: {\n            enabled: true,\n            strategy: 'aggressive',\n            steps: [10, 25, 50, 75, 100],\n            healthChecks: [\n                { name: 'connectivity', timeoutMs: 300 },\n                { name: 'replication', maxLagMs: 200 },\n                { name: 'quorum', minNodes: 3 }\n            ]\n        }\n    }\n\n        ^^^ Credentials\n        username = 'nebula_app'\n        password = '****'\n        rotateEveryDays = 45\n        history = [\n            { rotatedAt: '2025-05-10', reason: 'scheduled' },\n            { rotatedAt: '2025-03-02', reason: 'key-compromise' },\n            { rotatedAt: '2024-12-15', reason: 'policy-change' }\n        ]\n\n    ^^ API\n    baseUrl = 'https://api.nebula.io'\n    publicEndpoints = ['/health', '/status', '/version']\n    internalEndpoints = ['/admin', '/metrics', '/orchestrator', '/scheduler']\n\n        ^^^ Auth\n        provider = 'oidc'\n        tokenTTLSeconds = 5400\n        scopes = ['read', 'write', 'deploy', 'audit']\n\n            ^^^^ Clients\n            web = {\n                clientId: 'nebula-web-prod',\n                redirectUri: 'https://nebula.io/auth/callback',\n                allowedOrigins: ['https://nebula.io', 'https://console.nebula.io'],\n                secrets: [\n                    { id: 'alpha', value: 'QX7faP9', active: true },\n                    { id: 'beta', value: 'LM8KdW2', active: true },\n                    { id: 'legacy', value: 'OLD-KEY-DO-NOT-USE', active: false }\n                ]\n            }\n\n            mobile = {\n                clientId: 'nebula-mobile',\n                redirectUri: 'nebula://auth',\n                platforms: [\n                    { name: 'ios', minVersion: '15.2', enabled: true },\n                    { name: 'android', minVersion: '11', enabled: true },\n                    { name: 'harmonyos', minVersion: '4', enabled: false }\n                ],\n                refreshPolicy: {\n                    enabled: true,\n                    limits: { perHour: 60, perDay: 600 },\n                    audit: [\n                        { event: 'refresh', severity: 'info' },\n                        { event: 'suspicious-location', severity: 'warning' },\n                        { event: 'credential-stuffing', severity: 'critical' }\n                    ]\n                }\n            }\n\n^ Logging\nlevel = 'debug'\nformat = 'ndjson'\noutputs = ['stdout', 'file', 'syslog']\n\n    ^^ File\n    path = '/srv/log/nebula/nebula.log'\n    maxSizeMB = 250\n    rotate = true\n    keepFiles = 30\n\n    ^^ Metrics\n    enabled = true\n    endpoint = '/internal/metrics'\n    sampleRate = 0.75\n\n^ Services\nenabled = true\n\n    ^^ Email\n    provider = 'ses'\n    host = 'email.nebula.io'\n    port = 465\n    secure = true\n    from = 'system@nebula.io'\n\n        ^^^ Credentials\n        user = 'mailer-nebula'\n        pass = 'MAIL-SEC-9921'\n\n    ^^ Cache\n    type = 'keydb'\n    host = 'cache.nebula.internal'\n    port = 6380\n    ttlSeconds = 1800\n\n        ^^^ Cluster\n        nodes = [\n            { host: 'cache-a.nebula', port: 6380, role: 'primary', zones: ['eu-north-1a'] },\n            { host: 'cache-b.nebula', port: 6380, role: 'replica', zones: ['eu-north-1b'] },\n            { host: 'cache-c.nebula', port: 6380, role: 'replica', zones: ['eu-north-1c'] },\n            { host: 'cache-d.nebula', port: 6380, role: 'observer', zones: ['eu-north-1a'] }\n        ]\n\n        ^^^ Failover\n        strategy = {\n            mode: 'predictive',\n            thresholds: { errorRate: 0.08, latencyMs: 180 },\n            actions: [\n                { step: 'drain-traffic', timeoutMs: 1500 },\n                { step: 'promote-replica', timeoutMs: 2000 },\n                { step: 'resync', propagate: true },\n                { step: 'notify', channels: ['pagerduty', 'slack', 'email'] }\n            ]\n        }\n\n^ Observability\ntracing = true\ntracingProvider = 'tempo'\ntraceSampleRate = 0.35\n\n    ^^ Exporters\n    jaeger = {\n        enabled: false,\n        endpoint: 'http://jaeger.internal/api/traces',\n        tags: {\n            region: 'eu-north',\n            environment: 'staging',\n            build: { version: '5.0.0-rc.4', commit: 'c8f91d2', dirty: true }\n        }\n    }\n\n    prometheus = {\n        enabled: true,\n        endpoint: 'http://prometheus.nebula:9090',\n        scrapeIntervals: [2, 5, 10, 30],\n        retention: { days: 90, maxSeries: 3500000 }\n    }\n\n^ Security\nallowedIPs = ['172.16.0.0/12', '100.64.0.0/10']\nblockedCountries = ['KP', 'NG', 'BY']\n\n    ^^ Policies\n    passwordMinLength = 18\n    require2FA = true\n    sessionTTLMinutes = 45\n\n        ^^^ Lockout\n        maxAttempts = 4\n        lockoutMinutes = 60\n        escalation = {\n            enabled: true,\n            notify: ['security@nebula.io', 'ciso@nebula.io'],\n            rules: [\n                { attempts: 3, action: 'captcha' },\n                { attempts: 4, action: 'temporary-block', minutes: 120 },\n                { attempts: 6, action: 'account-freeze' },\n                { attempts: 9, action: 'permanent-block' }\n            ]\n        }\n";

package/dist/dev/quick-test-samples/valid-inputs.js

@@ -0,0 +1,422 @@
+"use strict";
+// src/dev/quick-test-samples/valid-inputs.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validConfigComplexBigB = exports.validConfigComplexBigA = exports.validConfigComplex = exports.validConfigAdvanced = exports.validConfigWithObjects = exports.validConfigBasic = exports.validConfigShort = void 0;
+/**
+ * Development-only YINI samples.
+ *
+ * These inputs are used for quick manual testing during development
+ * via src/dev/quick-test-samples/main.ts. They are NOT part of the automated test suite.
+ *
+ * All real testing belongs in /tests/.
+ */
+exports.validConfigShort = `
+^ App
+name = 'Hello'
+`;
+exports.validConfigBasic = `
+^ App
+name = "My Application"
+version = 1.0
+features = ["search", "logging"]
+
+    // Nested sub-section under App
+    ^^ Database
+    host = "localhost"
+    port = 5432
+`;
+exports.validConfigWithObjects = `
+^ App
+  name = "Demo"
+  version = "1.0.0"
+  features = [ "search", "dark-mode" ]
+
+^ Database
+  host = "localhost"
+  port = 5432
+  auth = { user: "admin", pass: "secret" }
+`;
+/**
+ * Covers booleans, nulls, number formats, and deeper nesting
+ */
+exports.validConfigAdvanced = `
+^ Server
+  enabled = ON
+  timeout = 3.5
+  retries = 5
+  threshold = 1e-3
+  fallback = null
+
+  ^^ Logging
+     level = "info"
+     output = { file: "app.log", rotate: true }
+`;
+/**
+ * Covers arrays of objects and realistic structure
+ */
+exports.validConfigComplex = `
+^ App
+  services = [
+    { name: "api",  port: 8080 },
+    { name: "web",  port: 3000 },
+    { name: "auth", port: 9000 }
+  ]
+
+^ Security
+  roles = ["admin", "user", "guest"]
+  enabled = true
+`;
+/*
+  Covers:
+  - Sections & deep nesting
+  - Real-world domain structure
+  - Objects in arrays
+  - Arrays of objects
+  - Scalars of every type
+  - Complex policy logic
+  - Auth & security modeling
+  - Unicode in strings.
+  - Strings in double quotes.
+  - Large but readable
+ */
+exports.validConfigComplexBigA = `
+@YINI
+
+// Example A: Corporate SaaS Platform.
+
+^ App
+name = "Acme Platform"    // Example Platform
+description = "The word “Acme” has been used for over 100 years in technical and business examples."
+meaning = "It comes from Greek akmḗ (ἀκμή), meaning “the highest point” or “best”."
+version = "2.3.1"
+debug = OFF
+environment = "production"
+maintainers = ["ops@acme.com", "dev@acme.com"]
+
+    ^^ Features
+    enableSearch = true
+    enablePayments = true
+    enableAnalytics = false
+    experimental = ["new-ui", "streaming-api"]
+
+    ^^ Limits
+    maxUsers = 50000
+    requestTimeoutMs = 3500
+    retryPolicy = { maxRetries: 5, backoff: "exponential" }
+
+    ^^ Database
+    engine = "postgres"
+    host = "db.internal.acme.com"
+    port = 5432
+    ssl = true
+    pool = { min: 5, max: 50 }
+
+        ^^^ Credentials
+        username = "app_user"
+        password = "****"
+        rotateEveryDays = 90
+
+    ^^ API
+    baseUrl = "https://api.acme.com"
+    publicEndpoints = ["/health", "/status"]
+    internalEndpoints = ["/admin", "/metrics"]
+
+        ^^^ Auth
+        provider = "oauth2"
+        tokenTTLSeconds = 3600
+        scopes = ["read", "write", "admin"]
+
+            ^^^^ Clients
+            web = { clientId: "web-123", redirectUri: "https://acme.com/callback" }
+            mobile = { clientId: "mob-456", redirectUri: "acme://auth" }
+
+^ Logging
+level = "info"
+format = "json"
+outputs = ["stdout", "file"]
+
+    ^^ File
+    path = "/var/log/acme/app.log"
+    maxSizeMB = 100
+    rotate = true
+    keepFiles = 10
+
+    ^^ Metrics
+    enabled = true
+    endpoint = "/metrics"
+    sampleRate = 0.25
+
+^ Services
+enabled = true
+
+    ^^ Email
+    provider = "smtp"
+    host = "smtp.acme.com"
+    port = 587
+    secure = false
+    from = "no-reply@acme.com"
+
+        ^^^ Credentials
+        user = "mailer"
+        pass = "mailer-secret"
+
+    ^^ Cache
+    type = "redis"
+    host = "cache.internal.acme.com"
+    port = 6379
+    ttlSeconds = 600
+
+        ^^^ Cluster
+        nodes = [
+          { host: "cache-1.internal", port: 6379 },
+          { host: "cache-2.internal", port: 6379 },
+          { host: "cache-3.internal", port: 6379 }
+        ]
+
+^ Observability
+tracing = true
+tracingProvider = "opentelemetry"
+traceSampleRate = 0.1
+
+    ^^ Exporters
+    jaeger = { enabled: true, endpoint: "http://jaeger:14268/api/traces" }
+    prometheus = { enabled: true, endpoint: "http://prom:9090" }
+
+^ Security
+allowedIPs = ["10.0.0.0/8", "192.168.0.0/16"]
+blockedCountries = ["KP", "SD"]
+
+    ^^ Policies
+    passwordMinLength = 14
+    require2FA = true
+    sessionTTLMinutes = 120
+
+        ^^^ Lockout
+        maxAttempts = 5
+        lockoutMinutes = 30
+`;
+/*
+  Example B covers:
+  Covers:
+  - Nested arrays inside inline objects.
+  - Sections & deep nesting.
+  - Real-world domain structure.
+  - Objects in arrays.
+  - Arrays of objects.
+  - Scalars of every type.
+  - Complex policy logic.
+  - Auth & security modeling.
+  - Unicode in strings.
+  - Strings in single quotes.
+  - Large but readable.
+ */
+exports.validConfigComplexBigB = `
+@YINI
+
+// Example B: High-Security Distributed Control System.
+
+^ App
+name = 'Nebula Control Suite'
+description = 'A distributed operations platform for autonomous systems and edge analytics.'
+meaning = 'Nebula comes from Latin "nebula" meaning mist or cloud.'
+version = '5.0.0-rc.4'
+debug = ON
+environment = 'staging'
+maintainers = ['infra@nebula.io', 'platform@nebula.io', 'secops@nebula.io']
+
+    ^^ Features
+    enableSearch = false
+    enablePayments = false
+    enableAnalytics = true
+    experimental = ['vector-engine', 'adaptive-ui', 'ai-routing']
+
+    ^^ Limits
+    maxUsers = 120000
+    requestTimeoutMs = 7200
+    retryPolicy = {
+        maxRetries: 9,
+        backoff: 'fibonacci',
+        retryOn: ['timeout', '5xx', 'throttle'],
+        schedule: [
+            { attempt: 1, delayMs: 80 },
+            { attempt: 2, delayMs: 160 },
+            { attempt: 3, delayMs: 320 },
+            { attempt: 4, delayMs: 640 },
+            { attempt: 5, delayMs: 1280 }
+        ]
+    }
+
+    ^^ Database
+    engine = 'cockroachdb'
+    host = 'cluster.db.nebula.io'
+    port = 26257
+    ssl = true
+    pool = {
+        min: 12,
+        max: 120,
+        warmup: {
+            enabled: true,
+            strategy: 'aggressive',
+            steps: [10, 25, 50, 75, 100],
+            healthChecks: [
+                { name: 'connectivity', timeoutMs: 300 },
+                { name: 'replication', maxLagMs: 200 },
+                { name: 'quorum', minNodes: 3 }
+            ]
+        }
+    }
+
+        ^^^ Credentials
+        username = 'nebula_app'
+        password = '****'
+        rotateEveryDays = 45
+        history = [
+            { rotatedAt: '2025-05-10', reason: 'scheduled' },
+            { rotatedAt: '2025-03-02', reason: 'key-compromise' },
+            { rotatedAt: '2024-12-15', reason: 'policy-change' }
+        ]
+
+    ^^ API
+    baseUrl = 'https://api.nebula.io'
+    publicEndpoints = ['/health', '/status', '/version']
+    internalEndpoints = ['/admin', '/metrics', '/orchestrator', '/scheduler']
+
+        ^^^ Auth
+        provider = 'oidc'
+        tokenTTLSeconds = 5400
+        scopes = ['read', 'write', 'deploy', 'audit']
+
+            ^^^^ Clients
+            web = {
+                clientId: 'nebula-web-prod',
+                redirectUri: 'https://nebula.io/auth/callback',
+                allowedOrigins: ['https://nebula.io', 'https://console.nebula.io'],
+                secrets: [
+                    { id: 'alpha', value: 'QX7faP9', active: true },
+                    { id: 'beta', value: 'LM8KdW2', active: true },
+                    { id: 'legacy', value: 'OLD-KEY-DO-NOT-USE', active: false }
+                ]
+            }
+
+            mobile = {
+                clientId: 'nebula-mobile',
+                redirectUri: 'nebula://auth',
+                platforms: [
+                    { name: 'ios', minVersion: '15.2', enabled: true },
+                    { name: 'android', minVersion: '11', enabled: true },
+                    { name: 'harmonyos', minVersion: '4', enabled: false }
+                ],
+                refreshPolicy: {
+                    enabled: true,
+                    limits: { perHour: 60, perDay: 600 },
+                    audit: [
+                        { event: 'refresh', severity: 'info' },
+                        { event: 'suspicious-location', severity: 'warning' },
+                        { event: 'credential-stuffing', severity: 'critical' }
+                    ]
+                }
+            }
+
+^ Logging
+level = 'debug'
+format = 'ndjson'
+outputs = ['stdout', 'file', 'syslog']
+
+    ^^ File
+    path = '/srv/log/nebula/nebula.log'
+    maxSizeMB = 250
+    rotate = true
+    keepFiles = 30
+
+    ^^ Metrics
+    enabled = true
+    endpoint = '/internal/metrics'
+    sampleRate = 0.75
+
+^ Services
+enabled = true
+
+    ^^ Email
+    provider = 'ses'
+    host = 'email.nebula.io'
+    port = 465
+    secure = true
+    from = 'system@nebula.io'
+
+        ^^^ Credentials
+        user = 'mailer-nebula'
+        pass = 'MAIL-SEC-9921'
+
+    ^^ Cache
+    type = 'keydb'
+    host = 'cache.nebula.internal'
+    port = 6380
+    ttlSeconds = 1800
+
+        ^^^ Cluster
+        nodes = [
+            { host: 'cache-a.nebula', port: 6380, role: 'primary', zones: ['eu-north-1a'] },
+            { host: 'cache-b.nebula', port: 6380, role: 'replica', zones: ['eu-north-1b'] },
+            { host: 'cache-c.nebula', port: 6380, role: 'replica', zones: ['eu-north-1c'] },
+            { host: 'cache-d.nebula', port: 6380, role: 'observer', zones: ['eu-north-1a'] }
+        ]
+
+        ^^^ Failover
+        strategy = {
+            mode: 'predictive',
+            thresholds: { errorRate: 0.08, latencyMs: 180 },
+            actions: [
+                { step: 'drain-traffic', timeoutMs: 1500 },
+                { step: 'promote-replica', timeoutMs: 2000 },
+                { step: 'resync', propagate: true },
+                { step: 'notify', channels: ['pagerduty', 'slack', 'email'] }
+            ]
+        }
+
+^ Observability
+tracing = true
+tracingProvider = 'tempo'
+traceSampleRate = 0.35
+
+    ^^ Exporters
+    jaeger = {
+        enabled: false,
+        endpoint: 'http://jaeger.internal/api/traces',
+        tags: {
+            region: 'eu-north',
+            environment: 'staging',
+            build: { version: '5.0.0-rc.4', commit: 'c8f91d2', dirty: true }
+        }
+    }
+
+    prometheus = {
+        enabled: true,
+        endpoint: 'http://prometheus.nebula:9090',
+        scrapeIntervals: [2, 5, 10, 30],
+        retention: { days: 90, maxSeries: 3500000 }
+    }
+
+^ Security
+allowedIPs = ['172.16.0.0/12', '100.64.0.0/10']
+blockedCountries = ['KP', 'NG', 'BY']
+
+    ^^ Policies
+    passwordMinLength = 18
+    require2FA = true
+    sessionTTLMinutes = 45
+
+        ^^^ Lockout
+        maxAttempts = 4
+        lockoutMinutes = 60
+        escalation = {
+            enabled: true,
+            notify: ['security@nebula.io', 'ciso@nebula.io'],
+            rules: [
+                { attempts: 3, action: 'captcha' },
+                { attempts: 4, action: 'temporary-block', minutes: 120 },
+                { attempts: 6, action: 'account-freeze' },
+                { attempts: 9, action: 'permanent-block' }
+            ]
+        }
+`;
+//# sourceMappingURL=valid-inputs.js.map

package/dist/dev/quick-test-samples/valid-inputs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valid-inputs.js","sourceRoot":"","sources":["../../../src/dev/quick-test-samples/valid-inputs.ts"],"names":[],"mappings":";AAAA,6CAA6C;;;AAE7C;;;;;;;GAOG;AAEU,QAAA,gBAAgB,GAAG;;;CAG/B,CAAA;AAEY,QAAA,gBAAgB,GAAG;;;;;;;;;;CAU/B,CAAA;AAEY,QAAA,sBAAsB,GAAG;;;;;;;;;;CAUrC,CAAA;AAED;;GAEG;AACU,QAAA,mBAAmB,GAAG;;;;;;;;;;;CAWlC,CAAA;AAED;;GAEG;AACU,QAAA,kBAAkB,GAAG;;;;;;;;;;;CAWjC,CAAA;AAED;;;;;;;;;;;;GAYG;AACU,QAAA,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmHrC,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACU,QAAA,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgNrC,CAAA"}

package/dist/index.js

@@ -1,5 +1,5 @@
 "use strict";
-// File: src/index.ts
+// src/index.ts
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,qBAAqB;;;;;;AAErB;;;;;;;;;;;;;EAaE;AAEF,kDAAyB;AAEzB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wFAAwF;AACxF,kBAAe,cAAI,CAAA,CAAC,sBAAsB;AAE7B,QAAA,KAAK,GAAG,cAAI,CAAC,KAAK,CAAA;AAClB,QAAA,SAAS,GAAG,cAAI,CAAC,SAAS,CAAA;AAC1B,QAAA,UAAU,GAAG,cAAI,CAAC,UAAU,CAAA;AAC5B,QAAA,UAAU,GAAG,cAAI,CAAC,UAAU,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,eAAe;;;;;;AAEf;;;;;;;;;;;;;EAaE;AAEF,kDAAyB;AAEzB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wFAAwF;AACxF,kBAAe,cAAI,CAAA,CAAC,sBAAsB;AAE7B,QAAA,KAAK,GAAG,cAAI,CAAC,KAAK,CAAA;AAClB,QAAA,SAAS,GAAG,cAAI,CAAC,SAAS,CAAA;AAC1B,QAAA,UAAU,GAAG,cAAI,CAAC,UAAU,CAAA;AAC5B,QAAA,UAAU,GAAG,cAAI,CAAC,UAAU,CAAA"}

package/dist/parsers/parseString.d.ts

@@ -1,2 +1,3 @@
-declare const parseStringLiteral: (raw: string) => string;
+import { IParsedStringInput } from '../core/internalTypes';
+declare const parseStringLiteral: ({ strKind, value }: IParsedStringInput) => string;
 export default parseStringLiteral;

package/dist/parsers/parseString.js

@@ -1,40 +1,139 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const env_1 = require("../config/env");
-const print_1 = require("../utils/print");
-const parseStringLiteral = (raw) => {
-    (0, print_1.debugPrint)('-> Entered parseStringLiteral(..)');
-    (0, print_1.debugPrint)('raw = >>>' + raw + '<<<');
-    /*
-            Extracts an optional prefix (C, c, H, or h) and identifies whether
-            the string is triple-quoted, double-quoted, or single-quoted.
-        */
-    const prefixMatch = raw.match(/^(C|c|H|h|R|r)?("""|"|')/);
-    (0, print_1.debugPrint)('prefixMatch:');
-    if ((0, env_1.isDebug)()) {
-        console.debug(prefixMatch);
+const isHex = (c) => /^[0-9a-fA-F]$/.test(c);
+const isOctal = (c) => /^[0-7]$/.test(c);
+function normalizeHyperWhitespace(input) {
+    return input.replace(/[\s\r\n]+/g, ' ').trim();
+}
+const parseClassicEscapes = (input) => {
+    let result = '';
+    for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch !== '\\') {
+            // Control character enforcement (U+0000–U+001F except tab).
+            const code = ch.charCodeAt(0);
+            if (code < 0x20 && ch !== '\t') {
+                throw new Error(`Unescaped control character U+${code
+                    .toString(16)
+                    .padStart(4, '0')}`);
+            }
+            result += ch;
+            continue;
+        }
+        // Escape sequence.
+        const next = input[++i];
+        if (!next)
+            throw new Error('Invalid escape sequence at end of string');
+        switch (next) {
+            case '\\':
+                result += '\\';
+                break;
+            case '"':
+                result += '"';
+                break;
+            case "'":
+                result += "'";
+                break;
+            case '/':
+                result += '/';
+                break;
+            case '0':
+                result += '\0';
+                break;
+            case '?':
+                result += '?';
+                break;
+            case 'a':
+                result += '\x07';
+                break;
+            case 'b':
+                result += '\b';
+                break;
+            case 'f':
+                result += '\f';
+                break;
+            case 'n':
+                result += '\n';
+                break;
+            case 'r':
+                result += '\r';
+                break;
+            case 't':
+                result += '\t';
+                break;
+            case 'v':
+                result += '\v';
+                break;
+            case 'x': {
+                const hex = input.slice(i + 1, i + 3);
+                if (hex.length !== 2 || ![...hex].every(isHex)) {
+                    throw new Error(`Invalid \\x escape`);
+                }
+                result += String.fromCharCode(parseInt(hex, 16));
+                i += 2;
+                break;
+            }
+            case 'u': {
+                const hex = input.slice(i + 1, i + 5);
+                if (hex.length !== 4 || ![...hex].every(isHex)) {
+                    throw new Error(`Invalid \\u escape`);
+                }
+                result += String.fromCharCode(parseInt(hex, 16));
+                i += 4;
+                break;
+            }
+            case 'U': {
+                const hex = input.slice(i + 1, i + 9);
+                if (hex.length !== 8 || ![...hex].every(isHex)) {
+                    throw new Error(`Invalid \\U escape`);
+                }
+                const codePoint = parseInt(hex, 16);
+                result += String.fromCodePoint(codePoint);
+                i += 8;
+                break;
+            }
+            case 'o': {
+                let oct = '';
+                let j = i + 1;
+                while (j < input.length &&
+                    oct.length < 3 &&
+                    isOctal(input[j])) {
+                    oct += input[j];
+                    j++;
+                }
+                if (oct.length === 0) {
+                    throw new Error(`Invalid \\o escape`);
+                }
+                const value = parseInt(oct, 8);
+                if (value > 0o377) {
+                    throw new Error(`Octal escape out of range`);
+                }
+                result += String.fromCharCode(value);
+                i += oct.length;
+                if (j < input.length && /[0-9]/.test(input[j])) {
+                    throw new Error(`Invalid \\o escape`);
+                }
+                break;
+            }
+            default:
+                throw new Error(`Invalid escape sequence \\${next}`);
+        }
     }
-    let prefix = prefixMatch ? prefixMatch[1]?.toUpperCase() : '';
-    (0, print_1.debugPrint)('          prefix = ' + prefix);
-    let quoteType = prefixMatch ? prefixMatch[2] : '';
-    (0, print_1.debugPrint)('       quoteType = ' + quoteType);
-    (0, print_1.debugPrint)('quoteType.length = ' + quoteType.length);
-    // Extracts the substring after removing the initial prefix (if any)
-    // and quotes at the start (prefix.length + quoteType.length) and the
-    // quotes at the end (-quoteType.length).
-    let inner = raw.slice((prefix?.length || 0) + quoteType.length, -quoteType.length);
-    (0, print_1.debugPrint)('inner (raw) = ' + inner);
-    if (prefix === 'C') {
-        inner = inner
-            .replace(/\\n/g, '\n')
-            .replace(/\\t/g, '\t')
-            .replace(/\\r/g, '\r');
-    }
-    else if (prefix === 'H') {
-        inner = inner.replace(/[\s\n\r]+/g, ' ').trim();
+    return result;
+};
+const parseStringLiteral = ({ strKind, value }) => {
+    switch (strKind) {
+        case 'raw':
+        case 'triple-raw':
+            return value;
+        case 'classic':
+        case 'triple-classic':
+            return parseClassicEscapes(value);
+        case 'hyper':
+            return normalizeHyperWhitespace(value);
+        default:
+            throw new Error(`Unknown string kind: ${strKind}`);
     }
-    (0, print_1.debugPrint)('inner (reformat) = ' + inner);
-    return inner;
 };
 exports.default = parseStringLiteral;
 //# sourceMappingURL=parseString.js.map