@routier/core 0.2.1 → 0.4.0

package/dist/pipeline/index.js

@@ -1,47 +1,16 @@
 var __webpack_modules__ = ({
-"./src/pipeline/SyncronousQueue.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+416(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  SyncronousQueue: () => (SyncronousQueue)
+  U: () => (WorkPipeline),
+  k: () => (TrampolinePipeline)
 });
-class SyncronousQueue {
-    _queue = [];
-    _current = null;
-    enqueue(unitOfWork) {
-        this._queue.push(unitOfWork);
-        this._next();
-    }
-    _next() {
-        if (this._current != null || this._queue.length === 0) {
-            return;
-        }
-        // Take first item
-        this._current = this._queue.shift() ?? null;
-        if (this._current == null) {
-            return;
-        }
-        this._current(() => {
-            this._current = null;
-            this._next();
-        });
-    }
-}
-
-
-},
-"./src/pipeline/TrampolinePipeline.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  TrampolinePipeline: () => (TrampolinePipeline),
-  WorkPipeline: () => (WorkPipeline)
-});
-/* import */ var _utilities__rspack_import_0 = __webpack_require__("./src/utilities/logger.ts");
-/* import */ var _results__rspack_import_1 = __webpack_require__("./src/results/Result.ts");
+/* import */ var _utilities__rspack_import_0 = __webpack_require__(581);
+/* import */ var _results__rspack_import_1 = __webpack_require__(718);
 
 
 class TrampolinePipeline {
     _list = [];
-    _hasErrored = false; // Flag to prevent calling done on error
+    _hasErrored = false;
     filter(initialData, done) {
         this._hasErrored = false; // Reset error flag on new execution
         if (this._list.length === 0) {
@@ -53,17 +22,16 @@ class TrampolinePipeline {
         let isRunning = false; // Guard against overlapping trampoline calls
         try {
             // --- Revised Completion Logic --- (Moved up for clarity)
-            const finalStepSentinel = () => {
+            const finalStepSentinel = ()=>{
                 // Only call done if no error has occurred
                 if (!this._hasErrored) {
                     done(currentData);
                 }
                 return null; // Stop the trampoline
             };
-            const createStepRevised = (idx) => {
-                return () => {
-                    if (this._hasErrored)
-                        return null; // Stop if an error occurred elsewhere
+            const createStepRevised = (idx)=>{
+                return ()=>{
+                    if (this._hasErrored) return null; // Stop if an error occurred elsewhere
                     if (idx >= this._list.length) {
                         return finalStepSentinel(); // Execute the dedicated final step
                     }
@@ -72,10 +40,10 @@ class TrampolinePipeline {
                     let syncCallbackResult = null;
                     let calledSync = false;
                     try {
-                        processor(currentData, (result, error) => {
+                        processor(currentData, (result, error)=>{
                             // --- Error Handling ---
                             if (error) {
-                                _utilities__rspack_import_0.logger.error(`Error reported by processor at index ${idx}:`, error);
+                                _utilities__rspack_import_0/* .logger.error */.vF.error(`Error reported by processor at index ${idx}:`, error);
                                 this._hasErrored = true; // Set flag
                                 // Throw the error to be caught by outer try...catch blocks
                                 throw error;
@@ -89,16 +57,14 @@ class TrampolinePipeline {
                                 // Callback was synchronous
                                 syncCallbackResult = nextStep; // Store next step function
                                 calledSync = true;
-                            }
-                            else {
+                            } else {
                                 // Callback was asynchronous, restart trampoline
                                 trampoline(nextStep);
                             }
                         });
-                    }
-                    catch (error) {
-                        if (!this._hasErrored) { // Check flag to avoid double logging if error was from callback
-                            _utilities__rspack_import_0.logger.error(`Error thrown by processor at index ${idx} or its callback:`, error);
+                    } catch (error) {
+                        if (!this._hasErrored) {
+                            _utilities__rspack_import_0/* .logger.error */.vF.error(`Error thrown by processor at index ${idx} or its callback:`, error);
                             this._hasErrored = true;
                         }
                         // Rethrow to be caught by the trampoline's catch block
@@ -107,21 +73,20 @@ class TrampolinePipeline {
                     if (calledSync) {
                         // Return the next step function for the sync loop
                         return syncCallbackResult;
-                    }
-                    else {
+                    } else {
                         // Pause trampoline for async, loop will stop as step returns null
                         return null;
                     }
                 };
             };
             // The trampoline loop
-            const trampoline = (step) => {
+            const trampoline = (step)=>{
                 if (isRunning) {
                     return;
                 }
                 isRunning = true;
                 let currentStep = step;
-                while (currentStep !== null) {
+                while(currentStep !== null){
                     try {
                         // Stop immediately if an error was flagged elsewhere
                         if (this._hasErrored) {
@@ -129,29 +94,39 @@ class TrampolinePipeline {
                             break;
                         }
                         currentStep = currentStep(); // Execute step, get next step or null
-                    }
-                    catch (trampolineError) {
+                    } catch (trampolineError) {
                         // Catch errors propagated from step execution (processor or callback errors)
-                        if (!this._hasErrored) { // Avoid double logging
-                            _utilities__rspack_import_0.logger.error("Error during trampoline step execution:", trampolineError);
+                        if (!this._hasErrored) {
+                            _utilities__rspack_import_0/* .logger.error */.vF.error("Error during trampoline step execution:", trampolineError);
                             this._hasErrored = true;
                         }
                         currentStep = null; // Stop the loop
-                        // We don't call `done` here because an error occurred.
-                        // The application should handle the uncaught exception if desired.
-                        break; // Explicitly break loop on error
+                        // Report the failure to the caller.
+                        //
+                        // This used to break without calling `done`, on the reasoning that
+                        // the application should handle the uncaught exception. It cannot:
+                        // the error is caught right here, so nothing escapes to be handled,
+                        // and every caller awaiting the callback waits forever. A hang is
+                        // strictly worse than an error — it gives the caller nothing to act
+                        // on and no way to time out.
+                        //
+                        // `done` runs exactly once per execution: this path returns
+                        // immediately, and finalStepSentinel checks `_hasErrored` before
+                        // reporting success, so the two are mutually exclusive.
+                        isRunning = false;
+                        done(currentData, trampolineError);
+                        return;
                     }
                 }
                 // Loop ends when currentStep is null or loop is broken by error
                 isRunning = false;
-                // Completion check is now handled by finalStepSentinel ensuring `done` isn't called on error.
+            // Completion check is now handled by finalStepSentinel ensuring `done` isn't called on error.
             };
             // --- Start the process ---
             index = 0; // Reset index
             currentData = initialData; // Reset data
             trampoline(createStepRevised(0)); // Start with the revised step creator
-        }
-        catch (error) {
+        } catch (error) {
             done(currentData, error);
         }
     }
@@ -160,44 +135,42 @@ class TrampolinePipeline {
         return this;
     }
     pipeEach(items, fn, map) {
-        for (let i = 0, length = items.length; i < length; i++) {
-            this.pipe((previous, done) => {
-                fn(map(previous, _results__rspack_import_1.Result.success(items[i])), done);
+        for(let i = 0, length = items.length; i < length; i++){
+            this.pipe((previous, done)=>{
+                fn(map(previous, _results__rspack_import_1/* .Result.success */.Q.success(items[i])), done);
             });
         }
     }
 }
 /**
  * Processes functions with callbacks asynchronously.
- *
+ * 
  * This pipeline handles work items that contain callback functions,
  * executing them in an asynchronous manner while maintaining proper
  * flow control and error handling.
- */
-class WorkPipeline {
+ */ class WorkPipeline {
     unitsOfWork = [];
-    _hasErrored = false; // Flag to prevent calling done on error
+    _hasErrored = false;
     filter(done) {
         this._hasErrored = false; // Reset error flag on new execution
         if (this.unitsOfWork.length === 0) {
-            done(_results__rspack_import_1.Result.success());
+            done(_results__rspack_import_1/* .Result.success */.Q.success());
             return;
         }
         let index = 0;
         let isRunning = false; // Guard against overlapping trampoline calls
         try {
             // --- Revised Completion Logic --- (Moved up for clarity)
-            const finalStepSentinel = () => {
+            const finalStepSentinel = ()=>{
                 // Only call done if no error has occurred
                 if (!this._hasErrored) {
-                    done(_results__rspack_import_1.Result.success());
+                    done(_results__rspack_import_1/* .Result.success */.Q.success());
                 }
                 return null; // Stop the trampoline
             };
-            const createStepRevised = (idx) => {
-                return () => {
-                    if (this._hasErrored)
-                        return null; // Stop if an error occurred elsewhere
+            const createStepRevised = (idx)=>{
+                return ()=>{
+                    if (this._hasErrored) return null; // Stop if an error occurred elsewhere
                     if (idx >= this.unitsOfWork.length) {
                         return finalStepSentinel(); // Execute the dedicated final step
                     }
@@ -206,10 +179,10 @@ class WorkPipeline {
                     let syncCallbackResult = null;
                     let calledSync = false;
                     try {
-                        processor((result) => {
+                        processor((result)=>{
                             // --- Error Handling ---
-                            if (result.ok === _results__rspack_import_1.Result.ERROR) {
-                                _utilities__rspack_import_0.logger.error(`Error reported by AsyncPipeline at index ${idx}:`, result.error);
+                            if (result.ok === _results__rspack_import_1/* .Result.ERROR */.Q.ERROR) {
+                                _utilities__rspack_import_0/* .logger.error */.vF.error(`Error reported by AsyncPipeline at index ${idx}:`, result.error);
                                 this._hasErrored = true; // Set flag
                                 // Throw the error to be caught by outer try...catch blocks
                                 throw result.error;
@@ -222,16 +195,14 @@ class WorkPipeline {
                                 // Callback was synchronous
                                 syncCallbackResult = nextStep; // Store next step function
                                 calledSync = true;
-                            }
-                            else {
+                            } else {
                                 // Callback was asynchronous, restart trampoline
                                 trampoline(nextStep);
                             }
                         });
-                    }
-                    catch (error) {
-                        if (!this._hasErrored) { // Check flag to avoid double logging if error was from callback
-                            _utilities__rspack_import_0.logger.error(`Error thrown by processor at index ${idx} or its callback:`, error);
+                    } catch (error) {
+                        if (!this._hasErrored) {
+                            _utilities__rspack_import_0/* .logger.error */.vF.error(`Error thrown by processor at index ${idx} or its callback:`, error);
                             this._hasErrored = true;
                         }
                         // Rethrow to be caught by the trampoline's catch block
@@ -240,21 +211,20 @@ class WorkPipeline {
                     if (calledSync) {
                         // Return the next step function for the sync loop
                         return syncCallbackResult;
-                    }
-                    else {
+                    } else {
                         // Pause trampoline for async, loop will stop as step returns null
                         return null;
                     }
                 };
             };
             // The trampoline loop
-            const trampoline = (step) => {
+            const trampoline = (step)=>{
                 if (isRunning) {
                     return;
                 }
                 isRunning = true;
                 let currentStep = step;
-                while (currentStep !== null) {
+                while(currentStep !== null){
                     try {
                         // Stop immediately if an error was flagged elsewhere
                         if (this._hasErrored) {
@@ -262,29 +232,30 @@ class WorkPipeline {
                             break;
                         }
                         currentStep = currentStep(); // Execute step, get next step or null
-                    }
-                    catch (trampolineError) {
+                    } catch (trampolineError) {
                         // Catch errors propagated from step execution (processor or callback errors)
-                        if (!this._hasErrored) { // Avoid double logging
-                            _utilities__rspack_import_0.logger.error("Error during trampoline step execution:", trampolineError);
+                        if (!this._hasErrored) {
+                            _utilities__rspack_import_0/* .logger.error */.vF.error("Error during trampoline step execution:", trampolineError);
                             this._hasErrored = true;
                         }
                         currentStep = null; // Stop the loop
-                        // We don't call `done` here because an error occurred.
-                        // The application should handle the uncaught exception if desired.
-                        break; // Explicitly break loop on error
+                        // Report the failure to the caller. See the note on the same path in
+                        // TrampolinePipeline: swallowing the error here left every caller
+                        // awaiting `done` hanging instead of receiving a failure.
+                        isRunning = false;
+                        done(_results__rspack_import_1/* .Result.error */.Q.error(trampolineError));
+                        return;
                     }
                 }
                 // Loop ends when currentStep is null or loop is broken by error
                 isRunning = false;
-                // Completion check is now handled by finalStepSentinel ensuring `done` isn't called on error.
+            // Completion check is now handled by finalStepSentinel ensuring `done` isn't called on error.
             };
             // --- Start the process ---
             index = 0; // Reset index
             trampoline(createStepRevised(0)); // Start with the revised step creator
-        }
-        catch (error) {
-            done(_results__rspack_import_1.Result.error(error));
+        } catch (error) {
+            done(_results__rspack_import_1/* .Result.error */.Q.error(error));
         }
     }
     pipe(work) {
@@ -294,11 +265,9 @@ class WorkPipeline {
 
 
 },
-"./src/results/Result.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+718(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  PluginEventResult: () => (PluginEventResult),
-  Result: () => (Result)
+  Q: () => (Result)
 });
 class BaseResult {
     static ERROR = "error";
@@ -345,7 +314,7 @@ class Result extends BaseResult {
         };
     }
 }
-class PluginEventResult extends BaseResult {
+class PluginEventResult extends (/* unused pure expression or super */ null && (BaseResult)) {
     static success(id, data) {
         return {
             id,
@@ -377,54 +346,130 @@ class PluginEventResult extends BaseResult {
 
 
 },
-"./src/utilities/logger.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+581(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  logger: () => (logger)
+  vF: () => (logger)
 });
 /**
- * Enable logging by setting `globalThis.__ROUTIER_DEBUG__ = true` before any routier code runs.
- */
-const shouldLog = () => {
+ * Levelled logging, resolved once.
+ *
+ * Three things about the previous implementation drove this shape:
+ *
+ *  - **There was no way to turn logging off.** `globalThis.__ROUTIER_DEBUG__` was only ever
+ *    compared against `true`, so setting it to `false` did nothing — while
+ *    `docs/how-to/debug-logging.md` documented exactly that as the way to force logging off.
+ *    A documented switch that silently does nothing is worse than no switch.
+ *  - **`NODE_ENV === 'test'` enabled it.** Every Jest run therefore logged, because Jest always
+ *    sets `NODE_ENV=test`. Measured on the S7 stress scenario, which drives ~2,000 saves through
+ *    a plugin that logs three lines per query: 12.4s with logging, ~6s without. Test runners also
+ *    capture console output by snapshotting a stack trace per call, so the cost is far above what
+ *    writing to a terminal would suggest — and the output buries whatever the failure was.
+ *  - **It was all-or-nothing, and re-resolved per call.** An error could not be kept while debug
+ *    was dropped, and every one of the ~97 call sites re-read `globalThis` and `process.env`.
+ *
+ * Levels are compared numerically against a value cached at module load. Measured against a
+ * no-op console at 200k calls: an enabled call costs ~70ns, a call rejected by the gate ~3ns.
+ * Building the arguments the call site passes in accounts for ~0.2ns of that 3ns, which is why
+ * this keeps the ordinary `logger.debug(msg, payload)` signature instead of taking a thunk —
+ * a lazy API would recover 0.3% of an enabled call's cost and would have to change every call
+ * site to do it.
+ */ /** Ordered from most severe to most verbose. `silent` discards everything. */ const LOG_LEVELS = [
+    'silent',
+    'error',
+    'warn',
+    'info',
+    'debug'
+];
+/** Numeric rank, so a gate is one integer comparison. */ const RANK = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4
+};
+const isLogLevel = (value)=>typeof value === 'string' && LOG_LEVELS.includes(value);
+/**
+ * Resolves the configured level, in precedence order.
+ *
+ * Ordered most specific first: an explicit level beats a boolean flag, a boolean flag beats an
+ * environment variable, and an environment variable beats an inference from `NODE_ENV`. Anything
+ * unrecognised is ignored rather than treated as an error — a typo'd level should not take down
+ * an application, and `silent` is the safe direction to fall back to.
+ */ const resolveLevel = ()=>{
     if (typeof globalThis !== 'undefined') {
         const g = globalThis;
-        if (g.__ROUTIER_DEBUG__ === true)
-            return true;
+        if (isLogLevel(g.__ROUTIER_LOG_LEVEL__)) {
+            return g.__ROUTIER_LOG_LEVEL__;
+        }
+        // Both directions honoured. `=== false` used to fall through to the NODE_ENV checks
+        // below and re-enable the logging it was asked to suppress.
+        if (g.__ROUTIER_DEBUG__ === true) return 'debug';
+        if (g.__ROUTIER_DEBUG__ === false) return 'silent';
     }
+    // There is deliberately no `import.meta.env` branch, although the documentation used to
+    // promise one. It could never work: this package is bundled with rspack, which replaces
+    // `import.meta` with `undefined`, so the check would read the *library's* build-time
+    // environment rather than the application's — and referencing `import.meta` at all is a parse
+    // error under a CommonJS build target, which is how the test suite loads this file. Vite and
+    // similar apps set `__ROUTIER_LOG_LEVEL__` or `__ROUTIER_DEBUG__` from their own
+    // `import.meta.env`, which is what the docs now describe.
     if (typeof process !== 'undefined' && process.env != null) {
+        if (isLogLevel(process.env.ROUTIER_LOG_LEVEL)) {
+            return process.env.ROUTIER_LOG_LEVEL;
+        }
         const debug = process.env.DEBUG;
-        if (debug === 'routier' || debug === '*')
-            return true;
-        const env = "development"?.toLowerCase();
-        if (env === 'dev' || env === 'development' || env === 'test')
-            return true;
+        if (debug === 'routier' || debug === '*') return 'debug';
+        const env = "production"?.toLowerCase();
+        // `test` is deliberately absent. It used to be here, which meant no test suite anywhere
+        // could run Routier quietly. Opt in with DEBUG=routier or ROUTIER_LOG_LEVEL when a test
+        // needs the output.
+        if (env === 'dev' || env === 'development') return 'debug';
     }
-    return false;
+    return 'silent';
+};
+let level = resolveLevel();
+let rank = RANK[level];
+/**
+ * Overrides the level for the rest of the process.
+ *
+ * The configuration above is read once, at import, which is what makes the gate cheap — but it
+ * also means an application that decides its verbosity after startup, or a test that wants to
+ * assert on output, has no way in. This is that way in.
+ */ const setLogLevel = (next)=>{
+    if (isLogLevel(next) === false) {
+        throw new Error(`Unknown log level "${next}". Expected one of: ${LOG_LEVELS.join(', ')}`);
+    }
+    level = next;
+    rank = RANK[next];
+};
+const getLogLevel = ()=>level;
+/** Re-reads the environment. For tests that change it after this module was imported. */ const resetLogLevel = ()=>{
+    level = resolveLevel();
+    rank = RANK[level];
 };
-const tryLog = (type, ...args) => {
-    if (shouldLog()) {
-        console[type](...args);
+/**
+ * Whether a message at this level would be emitted.
+ *
+ * For the rare call site whose *arguments* are expensive to build — a serialization, a deep
+ * clone, a join over a large collection. An ordinary payload object is not worth guarding; see
+ * the measurement in the header.
+ */ const isLogLevelEnabled = (at)=>rank >= RANK[at];
+const emit = (at, method, args)=>{
+    if (rank < RANK[at]) {
+        return;
     }
+    // Resolved at call time rather than captured once: test harnesses and browser devtools both
+    // replace console methods after modules have loaded, and a captured reference would keep
+    // writing past the replacement.
+    console[method](...args);
 };
 const logger = {
-    log: (...args) => {
-        tryLog("log", ...args);
-    },
-    info: (...args) => {
-        tryLog("info", ...args);
-    },
-    warn: (...args) => {
-        tryLog("warn", ...args);
-    },
-    error: (...args) => {
-        tryLog("error", ...args);
-    },
-    debug: (...args) => {
-        tryLog("debug", ...args);
-    },
-    table: (...args) => {
-        tryLog("table", ...args);
-    },
+    /** General-purpose output. Carried at `info`, since `log` names a console method, not a level. */ log: (...args)=>emit('info', 'log', args),
+    info: (...args)=>emit('info', 'info', args),
+    warn: (...args)=>emit('warn', 'warn', args),
+    error: (...args)=>emit('error', 'error', args),
+    debug: (...args)=>emit('debug', 'debug', args),
+    /** Diagnostic tabular output; verbose by nature, so it sits at `debug`. */ table: (...args)=>emit('debug', 'table', args)
 };
 
 
@@ -468,35 +513,52 @@ __webpack_require__.d = (exports, definition) => {
 (() => {
 __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
 })();
-// webpack/runtime/make_namespace_object
-(() => {
-// define __esModule on exports
-__webpack_require__.r = (exports) => {
-	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-	}
-	Object.defineProperty(exports, '__esModule', { value: true });
-};
-})();
 var __webpack_exports__ = {};
 // This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
 (() => {
-__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  SyncronousQueue: () => (/* reexport safe */ _SyncronousQueue__rspack_import_0.SyncronousQueue),
-  TrampolinePipeline: () => (/* reexport safe */ _TrampolinePipeline__rspack_import_1.TrampolinePipeline),
-  WorkPipeline: () => (/* reexport safe */ _TrampolinePipeline__rspack_import_1.WorkPipeline)
+  kX: () => (/* reexport */ TrampolinePipeline/* .TrampolinePipeline */.k),
+  hq: () => (/* reexport */ SyncronousQueue),
+  UQ: () => (/* reexport */ TrampolinePipeline/* .WorkPipeline */.U)
 });
-/* import */ var _SyncronousQueue__rspack_import_0 = __webpack_require__("./src/pipeline/SyncronousQueue.ts");
-/* import */ var _TrampolinePipeline__rspack_import_1 = __webpack_require__("./src/pipeline/TrampolinePipeline.ts");
+
+;// CONCATENATED MODULE: ./src/pipeline/SyncronousQueue.ts
+class SyncronousQueue {
+    _queue = [];
+    _current = null;
+    enqueue(unitOfWork) {
+        this._queue.push(unitOfWork);
+        this._next();
+    }
+    _next() {
+        if (this._current != null || this._queue.length === 0) {
+            return;
+        }
+        // Take first item
+        this._current = this._queue.shift() ?? null;
+        if (this._current == null) {
+            return;
+        }
+        this._current(()=>{
+            this._current = null;
+            this._next();
+        });
+    }
+}
+
+// EXTERNAL MODULE: ./src/pipeline/TrampolinePipeline.ts
+var TrampolinePipeline = __webpack_require__(416);
+;// CONCATENATED MODULE: ./src/pipeline/index.ts
 
 
 
 })();
 
-var __webpack_exports__SyncronousQueue = __webpack_exports__.SyncronousQueue;
-var __webpack_exports__TrampolinePipeline = __webpack_exports__.TrampolinePipeline;
-var __webpack_exports__WorkPipeline = __webpack_exports__.WorkPipeline;
+var __webpack_exports__SyncronousQueue = __webpack_exports__.hq;
+var __webpack_exports__TrampolinePipeline = __webpack_exports__.kX;
+var __webpack_exports__WorkPipeline = __webpack_exports__.UQ;
 export { __webpack_exports__SyncronousQueue as SyncronousQueue, __webpack_exports__TrampolinePipeline as TrampolinePipeline, __webpack_exports__WorkPipeline as WorkPipeline };
 
 //# sourceMappingURL=index.js.map