solve-engine 2.15.0 → 2.17.0

package/dist/{BytecodeBuilder-CRYfrFfq.d.cts → BytecodeBuilder-aqVa7Plx.d.cts}

@@ -111,6 +111,16 @@ interface BytecodeProgram {
     opcodes: Uint8Array;
     numbers: Float64Array;
     strings: string[];
+    /**
+     * Numeric constants by opcode position, restored from a snapshot.
+     *
+     * Nothing in the compile path writes this: numbers are emitted inline into
+     * {@link numbers} instead. `build()` used to attach an empty Map to every
+     * program anyway, which was one allocation per compiled expression, around a
+     * tenth of parse-and-compile time, for a collection that was never read.
+     * It is left off now, and only {@link EngineSnapshot} sets it when restoring
+     * a program that carried one; every reader already guards on its absence.
+     */
     constants?: Map<number, number>;
     /**
      * Whether the program contains any async opcodes (CALL_PLUGIN, etc.).

package/dist/{BytecodeBuilder-CRYfrFfq.d.ts → BytecodeBuilder-aqVa7Plx.d.ts}

@@ -111,6 +111,16 @@ interface BytecodeProgram {
     opcodes: Uint8Array;
     numbers: Float64Array;
     strings: string[];
+    /**
+     * Numeric constants by opcode position, restored from a snapshot.
+     *
+     * Nothing in the compile path writes this: numbers are emitted inline into
+     * {@link numbers} instead. `build()` used to attach an empty Map to every
+     * program anyway, which was one allocation per compiled expression, around a
+     * tenth of parse-and-compile time, for a collection that was never read.
+     * It is left off now, and only {@link EngineSnapshot} sets it when restoring
+     * a program that carried one; every reader already guards on its absence.
+     */
     constants?: Map<number, number>;
     /**
      * Whether the program contains any async opcodes (CALL_PLUGIN, etc.).

package/dist/{EngineError-Cv5q4Rbv.d.cts → EngineError-DTk7I7hZ.d.cts}

@@ -313,6 +313,30 @@ declare class EngineError extends Error {
      * interop with no build-config change needed.
      */
     readonly cause?: unknown;
+    /**
+     * Whether a recoverable error captures a JavaScript stack trace.
+     *
+     * Off, because a recoverable EngineError is a value rather than a fault. A
+     * line of prose in a notepad is not an expression, so parsing it fails, and
+     * that failure is the answer for that line rather than a bug to debug. The
+     * engine builds one such error per non-expression line.
+     *
+     * Capturing a stack is not cheap, and its cost grows with how deep the stack
+     * is when it happens. Measured through `parseDocument`, where the throw site
+     * sits about a dozen frames down, each capture cost around 62 microseconds
+     * and a 250-line document built 74 of them: a CPU profile put the
+     * constructor at 46% of the whole pipeline, more than lexing, normalising,
+     * parsing and executing put together.
+     *
+     * Turn it on to debug where a recoverable error is raised from. Errors that
+     * are NOT recoverable always capture, since those are the genuine faults.
+     *
+     * @example
+     * ```ts
+     * EngineError.captureRecoverableStacks = true;
+     * ```
+     */
+    static captureRecoverableStacks: boolean;
     constructor(category: ErrorCategory, init: EngineErrorInit);
     /** `!recoverable`. See `EngineErrorInit.recoverable`'s doc comment for what this actually gates (message framing/telemetry, not whether evaluation continues). */
     isFatal(): boolean;

package/dist/{EngineError-Cv5q4Rbv.d.ts → EngineError-DTk7I7hZ.d.ts}

@@ -313,6 +313,30 @@ declare class EngineError extends Error {
      * interop with no build-config change needed.
      */
     readonly cause?: unknown;
+    /**
+     * Whether a recoverable error captures a JavaScript stack trace.
+     *
+     * Off, because a recoverable EngineError is a value rather than a fault. A
+     * line of prose in a notepad is not an expression, so parsing it fails, and
+     * that failure is the answer for that line rather than a bug to debug. The
+     * engine builds one such error per non-expression line.
+     *
+     * Capturing a stack is not cheap, and its cost grows with how deep the stack
+     * is when it happens. Measured through `parseDocument`, where the throw site
+     * sits about a dozen frames down, each capture cost around 62 microseconds
+     * and a 250-line document built 74 of them: a CPU profile put the
+     * constructor at 46% of the whole pipeline, more than lexing, normalising,
+     * parsing and executing put together.
+     *
+     * Turn it on to debug where a recoverable error is raised from. Errors that
+     * are NOT recoverable always capture, since those are the genuine faults.
+     *
+     * @example
+     * ```ts
+     * EngineError.captureRecoverableStacks = true;
+     * ```
+     */
+    static captureRecoverableStacks: boolean;
     constructor(category: ErrorCategory, init: EngineErrorInit);
     /** `!recoverable`. See `EngineErrorInit.recoverable`'s doc comment for what this actually gates (message framing/telemetry, not whether evaluation continues). */
     isFatal(): boolean;

package/dist/{PackageCompatibility-Cl7GF_Iu.d.ts → PackageCompatibility-BGXSFuL9.d.ts}

@@ -1,4 +1,4 @@
-import { I as IEnginePackage } from './PackageRegistry-CK_JoX50.js';
+import { I as IEnginePackage } from './PackageRegistry-BRoVOYzg.js';
 
 /**
  * Package load-time compatibility checking, the "detect overlapping

package/dist/{PackageCompatibility-C2IQZ_w3.d.cts → PackageCompatibility-BZCqaTOO.d.cts}

@@ -1,4 +1,4 @@
-import { I as IEnginePackage } from './PackageRegistry-CZO1IbS-.cjs';
+import { I as IEnginePackage } from './PackageRegistry-rMGnTh7W.cjs';
 
 /**
  * Package load-time compatibility checking, the "detect overlapping

package/dist/{PackageRegistry-CK_JoX50.d.ts → PackageRegistry-BRoVOYzg.d.ts}

@@ -1,12 +1,12 @@
-import { a as PrecedenceParser, b as PrefixParselet, I as InfixParselet } from './Parselet-CK0bNO1l.js';
+import { a as PrecedenceParser, b as PrefixParselet, I as InfixParselet } from './Parselet-B-WyUtX4.js';
 import { V as Value, b as ValueType } from './Value-DCTqTSeP.js';
 import { M as MarkdownLineType, L as Lexer, e as TokenCategory, c as LexerVocabulary } from './Lexer-CqagTewQ.js';
 import { IAsyncResolver } from './resolvers.js';
-import { T as TokenFusion, c as TokenNormalizer, a as NormalizerRule } from './TokenNormalizer-d7F1KQFs.js';
-import { D as DependencyGraph, V as VM, a as DagSnapshot, b as EngineContext, S as ScopeManager, P as PluginFunctionHandler } from './ScopeManager-C6c1WmJD.js';
-import { a as BytecodeProgram } from './BytecodeBuilder-CRYfrFfq.js';
+import { T as TokenFusion, c as TokenNormalizer, a as NormalizerRule } from './TokenNormalizer-OTPS0Otq.js';
+import { D as DependencyGraph, V as VM, a as DagSnapshot, b as EngineContext, S as ScopeManager, P as PluginFunctionHandler } from './ScopeManager-gB9UengK.js';
+import { a as BytecodeProgram } from './BytecodeBuilder-aqVa7Plx.js';
 import { QueryClient } from '@tanstack/query-core';
-import { E as EngineError } from './EngineError-Cv5q4Rbv.js';
+import { E as EngineError } from './EngineError-DTk7I7hZ.js';
 import { a as DiagnosticReportJSON, D as DiagnosticPipeline } from './pipeline-QIT4iD8f.js';
 import { T as Token } from './Token-CbP_OutD.js';
 import { E as EngineConfigOverride, a as EngineConfig } from './Configuration-BGQn-cJ8.js';
@@ -1191,6 +1191,32 @@ interface NormalizerOutput {
     }[];
     /** Post-normalization tokens ready for parsing */
     tokens: Token[];
+    /**
+     * Every registered rule with the shape it declared, in priority order.
+     *
+     * A rule that declares a shape is tried only where that shape can match; one
+     * that declares none is tried at every position of every line. That
+     * distinction is invisible from outside the engine and is the difference
+     * between a package costing the documents that use it and costing all of
+     * them, so the playground draws it.
+     */
+    ruleShapes?: {
+        name: string;
+        priority: number;
+        shape: readonly {
+            types?: readonly string[];
+            values?: readonly string[];
+        }[];
+        unshapedReason?: string;
+        indexedSlots: number;
+    }[];
+    /**
+     * How many rules could fire at each position of the normalised stream.
+     *
+     * One entry per token. Mostly zeroes, which is the point of the index: a
+     * position where nothing can match is rejected without calling a rule.
+     */
+    candidatesPerPosition?: number[];
     /**
      * All registered phrase → tokenType mappings from the PhraseTrie.
      * Populated by the engine at diagnostic stage build time so the
@@ -1478,6 +1504,18 @@ interface EngineOptions {
     config?: EngineConfigOverride;
     /** Turn on the diagnostic pipeline (per-stage timing and detail). Defaults to `false`. */
     diagnostics?: boolean;
+    /**
+     * Run a few throwaway expressions through the pipeline at construction, so
+     * the first real one is not the one that pays for JIT warmup.
+     *
+     * Off by default, because it moves cost rather than removing it: a process
+     * that evaluates one expression and exits pays for warming paths it never
+     * reuses. Turn it on for anything interactive, where the first keystroke is
+     * the one a person notices. See {@link ExpressionEngine.warmUp}.
+     *
+     * @default false
+     */
+    warmup?: boolean;
 }
 /**
  * Core expression evaluation engine, the top-level orchestrator.
@@ -1590,6 +1628,13 @@ declare class ExpressionEngine {
      *. See `api/PackageCompatibility.ts`'s module doc for why this exists.
      */
     private registeredPackages;
+    /**
+     * The merged `name -> fused token type` map every package's
+     * {@link IEnginePackage.callFusions} feeds, read live by the single
+     * {@link callFusionRule}. Kept in step with registration so one rule serves
+     * every `name(` call word instead of one rule per package.
+     */
+    private callFusions;
     /**
      * Incremental index behind the package-compatibility check. Kept in step
      * with {@link registeredPackages} so each `registerPackage` costs O(that
@@ -1643,6 +1688,41 @@ declare class ExpressionEngine {
      * had set, rather than assuming it was `null`.
      */
     getDocumentModel(): DocumentModel | null;
+    /**
+     * A handful of expressions run through the pipeline to warm it, chosen to
+     * cover the shapes the hot paths specialise on rather than to be
+     * interesting.
+     *
+     * V8 runs a function interpreted until it has been called enough times to
+     * be worth optimising, and it specialises on the types it has actually
+     * seen. So the point is breadth, not volume: a number, a unit, a phrase, a
+     * function call, a comparison and a string each drive a different branch of
+     * the lexer, the normalizer and the VM. Warming only with `1 + 1` would
+     * optimise those functions for integers and then deoptimise the moment a
+     * real document mentioned kilograms, which is worse than not warming at all.
+     */
+    private static readonly WARMUP_EXPRESSIONS;
+    /**
+     * Run the pipeline over a few throwaway expressions so the first real one
+     * is not the one that pays for JIT warmup.
+     *
+     * Nothing here reaches the engine's state: no variable is defined, no line
+     * is registered, no bytecode is cached and no async resolver is consulted.
+     * It lexes, normalises, parses, compiles and executes into a scratch
+     * builder and then drops the result, which is enough to move the hot
+     * functions past the interpreter and to build the normalizer's rule index.
+     *
+     * The cost lands on construction instead. That is the right trade for an
+     * editor, where the first keystroke is the one a person notices, and the
+     * wrong one for a process that evaluates a single expression and exits,
+     * which is why {@link EngineOptions.warmup} exists rather than this being
+     * unconditional.
+     *
+     * Failures are swallowed on purpose: a warmup expression that stops parsing
+     * because a package changed is a warmup that did less good, not a reason to
+     * refuse to construct an engine.
+     */
+    warmUp(): void;
     /**
      * Build the {@link LineExecutionContext} passed to `executeBytecode()`
      * for a given line. `lineNumber = -1` (the existing sentinel
@@ -3069,6 +3149,28 @@ interface IEnginePackage {
      * like implicit operator insertion.
      */
     normalizerRules?: NormalizerRule[];
+    /**
+     * Function-call words that fuse to a call token when immediately followed by
+     * `(`, keyed by the lower-cased word and mapped to the token type to mint.
+     * This is the declarative form of the common `name(` normalizer rule (the one
+     * `base64(`, `sha256(`, `length(`, ... all hand-wrote): the engine merges every
+     * package's `callFusions` into one shared map and runs a SINGLE rule for all of
+     * them, rather than one rule per package tried at every identifier.
+     *
+     * The fused token carries the lower-cased word as its value (the call parselet
+     * reads it to pick the function) and the original text as its raw value, and it
+     * does not fire after a `:` (so `:base64 = ...` stays a variable). For anything
+     * more than that plain shape (a different lookbehind, a deeper lookahead), write
+     * a {@link normalizerRules} entry instead.
+     *
+     * @example
+     * ```ts
+     * callFusions: { base64: "BASE64_FN" }
+     * // or, mapping many names to one token type:
+     * callFusions: Object.fromEntries(Object.keys(FUNCS).map((n) => [n, "TEXT_CALL"]))
+     * ```
+     */
+    callFusions?: Record<string, string>;
     /**
      * Semantic highlight categories for this package's custom token types
      * (introduced via {@link lexerVocabulary} or {@link normalizerRules}), the

package/dist/{PackageRegistry-CZO1IbS-.d.cts → PackageRegistry-rMGnTh7W.d.cts}

@@ -1,12 +1,12 @@
-import { a as PrecedenceParser, b as PrefixParselet, I as InfixParselet } from './Parselet-DOGmj6N6.cjs';
+import { a as PrecedenceParser, b as PrefixParselet, I as InfixParselet } from './Parselet-Bkbp9CKD.cjs';
 import { V as Value, b as ValueType } from './Value-DCTqTSeP.cjs';
 import { M as MarkdownLineType, L as Lexer, e as TokenCategory, c as LexerVocabulary } from './Lexer-CCHFDcgP.cjs';
 import { IAsyncResolver } from './resolvers.cjs';
-import { T as TokenFusion, c as TokenNormalizer, a as NormalizerRule } from './TokenNormalizer-BfTHg1qt.cjs';
-import { D as DependencyGraph, V as VM, a as DagSnapshot, b as EngineContext, S as ScopeManager, P as PluginFunctionHandler } from './ScopeManager-BtqiTVjG.cjs';
-import { a as BytecodeProgram } from './BytecodeBuilder-CRYfrFfq.cjs';
+import { T as TokenFusion, c as TokenNormalizer, a as NormalizerRule } from './TokenNormalizer-MXaKLJ_m.cjs';
+import { D as DependencyGraph, V as VM, a as DagSnapshot, b as EngineContext, S as ScopeManager, P as PluginFunctionHandler } from './ScopeManager-bCYewWVt.cjs';
+import { a as BytecodeProgram } from './BytecodeBuilder-aqVa7Plx.cjs';
 import { QueryClient } from '@tanstack/query-core';
-import { E as EngineError } from './EngineError-Cv5q4Rbv.cjs';
+import { E as EngineError } from './EngineError-DTk7I7hZ.cjs';
 import { a as DiagnosticReportJSON, D as DiagnosticPipeline } from './pipeline-B4wf3M1h.cjs';
 import { T as Token } from './Token-CbP_OutD.cjs';
 import { E as EngineConfigOverride, a as EngineConfig } from './Configuration-BGQn-cJ8.cjs';
@@ -1191,6 +1191,32 @@ interface NormalizerOutput {
     }[];
     /** Post-normalization tokens ready for parsing */
     tokens: Token[];
+    /**
+     * Every registered rule with the shape it declared, in priority order.
+     *
+     * A rule that declares a shape is tried only where that shape can match; one
+     * that declares none is tried at every position of every line. That
+     * distinction is invisible from outside the engine and is the difference
+     * between a package costing the documents that use it and costing all of
+     * them, so the playground draws it.
+     */
+    ruleShapes?: {
+        name: string;
+        priority: number;
+        shape: readonly {
+            types?: readonly string[];
+            values?: readonly string[];
+        }[];
+        unshapedReason?: string;
+        indexedSlots: number;
+    }[];
+    /**
+     * How many rules could fire at each position of the normalised stream.
+     *
+     * One entry per token. Mostly zeroes, which is the point of the index: a
+     * position where nothing can match is rejected without calling a rule.
+     */
+    candidatesPerPosition?: number[];
     /**
      * All registered phrase → tokenType mappings from the PhraseTrie.
      * Populated by the engine at diagnostic stage build time so the
@@ -1478,6 +1504,18 @@ interface EngineOptions {
     config?: EngineConfigOverride;
     /** Turn on the diagnostic pipeline (per-stage timing and detail). Defaults to `false`. */
     diagnostics?: boolean;
+    /**
+     * Run a few throwaway expressions through the pipeline at construction, so
+     * the first real one is not the one that pays for JIT warmup.
+     *
+     * Off by default, because it moves cost rather than removing it: a process
+     * that evaluates one expression and exits pays for warming paths it never
+     * reuses. Turn it on for anything interactive, where the first keystroke is
+     * the one a person notices. See {@link ExpressionEngine.warmUp}.
+     *
+     * @default false
+     */
+    warmup?: boolean;
 }
 /**
  * Core expression evaluation engine, the top-level orchestrator.
@@ -1590,6 +1628,13 @@ declare class ExpressionEngine {
      *. See `api/PackageCompatibility.ts`'s module doc for why this exists.
      */
     private registeredPackages;
+    /**
+     * The merged `name -> fused token type` map every package's
+     * {@link IEnginePackage.callFusions} feeds, read live by the single
+     * {@link callFusionRule}. Kept in step with registration so one rule serves
+     * every `name(` call word instead of one rule per package.
+     */
+    private callFusions;
     /**
      * Incremental index behind the package-compatibility check. Kept in step
      * with {@link registeredPackages} so each `registerPackage` costs O(that
@@ -1643,6 +1688,41 @@ declare class ExpressionEngine {
      * had set, rather than assuming it was `null`.
      */
     getDocumentModel(): DocumentModel | null;
+    /**
+     * A handful of expressions run through the pipeline to warm it, chosen to
+     * cover the shapes the hot paths specialise on rather than to be
+     * interesting.
+     *
+     * V8 runs a function interpreted until it has been called enough times to
+     * be worth optimising, and it specialises on the types it has actually
+     * seen. So the point is breadth, not volume: a number, a unit, a phrase, a
+     * function call, a comparison and a string each drive a different branch of
+     * the lexer, the normalizer and the VM. Warming only with `1 + 1` would
+     * optimise those functions for integers and then deoptimise the moment a
+     * real document mentioned kilograms, which is worse than not warming at all.
+     */
+    private static readonly WARMUP_EXPRESSIONS;
+    /**
+     * Run the pipeline over a few throwaway expressions so the first real one
+     * is not the one that pays for JIT warmup.
+     *
+     * Nothing here reaches the engine's state: no variable is defined, no line
+     * is registered, no bytecode is cached and no async resolver is consulted.
+     * It lexes, normalises, parses, compiles and executes into a scratch
+     * builder and then drops the result, which is enough to move the hot
+     * functions past the interpreter and to build the normalizer's rule index.
+     *
+     * The cost lands on construction instead. That is the right trade for an
+     * editor, where the first keystroke is the one a person notices, and the
+     * wrong one for a process that evaluates a single expression and exits,
+     * which is why {@link EngineOptions.warmup} exists rather than this being
+     * unconditional.
+     *
+     * Failures are swallowed on purpose: a warmup expression that stops parsing
+     * because a package changed is a warmup that did less good, not a reason to
+     * refuse to construct an engine.
+     */
+    warmUp(): void;
     /**
      * Build the {@link LineExecutionContext} passed to `executeBytecode()`
      * for a given line. `lineNumber = -1` (the existing sentinel
@@ -3069,6 +3149,28 @@ interface IEnginePackage {
      * like implicit operator insertion.
      */
     normalizerRules?: NormalizerRule[];
+    /**
+     * Function-call words that fuse to a call token when immediately followed by
+     * `(`, keyed by the lower-cased word and mapped to the token type to mint.
+     * This is the declarative form of the common `name(` normalizer rule (the one
+     * `base64(`, `sha256(`, `length(`, ... all hand-wrote): the engine merges every
+     * package's `callFusions` into one shared map and runs a SINGLE rule for all of
+     * them, rather than one rule per package tried at every identifier.
+     *
+     * The fused token carries the lower-cased word as its value (the call parselet
+     * reads it to pick the function) and the original text as its raw value, and it
+     * does not fire after a `:` (so `:base64 = ...` stays a variable). For anything
+     * more than that plain shape (a different lookbehind, a deeper lookahead), write
+     * a {@link normalizerRules} entry instead.
+     *
+     * @example
+     * ```ts
+     * callFusions: { base64: "BASE64_FN" }
+     * // or, mapping many names to one token type:
+     * callFusions: Object.fromEntries(Object.keys(FUNCS).map((n) => [n, "TEXT_CALL"]))
+     * ```
+     */
+    callFusions?: Record<string, string>;
     /**
      * Semantic highlight categories for this package's custom token types
      * (introduced via {@link lexerVocabulary} or {@link normalizerRules}), the

package/dist/{Parselet-CK0bNO1l.d.ts → Parselet-B-WyUtX4.d.ts}

@@ -1,4 +1,4 @@
-import { B as BytecodeBuilder } from './BytecodeBuilder-CRYfrFfq.js';
+import { B as BytecodeBuilder } from './BytecodeBuilder-aqVa7Plx.js';
 import { T as Token } from './Token-CbP_OutD.js';
 import { D as DiagnosticPipeline } from './pipeline-QIT4iD8f.js';
 
@@ -149,6 +149,10 @@ declare class PrecedenceParser {
     private diagnosticPipeline;
     private currentExpression;
     private localeCode;
+    /** The locale's decimal separator, cached from {@link localeCode}. */
+    private readonly decimalSeparator;
+    /** The locale's thousands separator, cached from {@link localeCode}. */
+    private readonly thousandsSeparator;
     /**
      * The binding power the current infix parselet is being invoked at, i.e. the
      * `minBp` of the expression it sits inside. Set immediately before each Tier-2

package/dist/{Parselet-DOGmj6N6.d.cts → Parselet-Bkbp9CKD.d.cts}

@@ -1,4 +1,4 @@
-import { B as BytecodeBuilder } from './BytecodeBuilder-CRYfrFfq.cjs';
+import { B as BytecodeBuilder } from './BytecodeBuilder-aqVa7Plx.cjs';
 import { T as Token } from './Token-CbP_OutD.cjs';
 import { D as DiagnosticPipeline } from './pipeline-B4wf3M1h.cjs';
 
@@ -149,6 +149,10 @@ declare class PrecedenceParser {
     private diagnosticPipeline;
     private currentExpression;
     private localeCode;
+    /** The locale's decimal separator, cached from {@link localeCode}. */
+    private readonly decimalSeparator;
+    /** The locale's thousands separator, cached from {@link localeCode}. */
+    private readonly thousandsSeparator;
     /**
      * The binding power the current infix parselet is being invoked at, i.e. the
      * `minBp` of the expression it sits inside. Set immediately before each Tier-2

package/dist/{ScopeManager-BtqiTVjG.d.cts → ScopeManager-bCYewWVt.d.cts}

@@ -1,6 +1,6 @@
 import { V as Value } from './Value-DCTqTSeP.cjs';
-import { U as UserFunctionDef, A as AnonymousBodyDef, a as BytecodeProgram } from './BytecodeBuilder-CRYfrFfq.cjs';
-import { E as EngineError } from './EngineError-Cv5q4Rbv.cjs';
+import { U as UserFunctionDef, A as AnonymousBodyDef, a as BytecodeProgram } from './BytecodeBuilder-aqVa7Plx.cjs';
+import { E as EngineError } from './EngineError-DTk7I7hZ.cjs';
 import { D as DiagnosticPipeline } from './pipeline-B4wf3M1h.cjs';
 
 /**

package/dist/{ScopeManager-C6c1WmJD.d.ts → ScopeManager-gB9UengK.d.ts}

@@ -1,6 +1,6 @@
 import { V as Value } from './Value-DCTqTSeP.js';
-import { U as UserFunctionDef, A as AnonymousBodyDef, a as BytecodeProgram } from './BytecodeBuilder-CRYfrFfq.js';
-import { E as EngineError } from './EngineError-Cv5q4Rbv.js';
+import { U as UserFunctionDef, A as AnonymousBodyDef, a as BytecodeProgram } from './BytecodeBuilder-aqVa7Plx.js';
+import { E as EngineError } from './EngineError-DTk7I7hZ.js';
 import { D as DiagnosticPipeline } from './pipeline-QIT4iD8f.js';
 
 /**