@quietsapa/qsl 0.1.0

package/dist/qsl.mjs

@@ -0,0 +1,1800 @@
+const core = {
+  /**
+   * Constants
+   */
+  VERSION: "0.1.0",
+  PREFIX: "qsl-",
+  FLOW_TYPE: {
+    DEFAULT: "default",
+    ORDERED: "ordered"
+  },
+  FLOW_STATE: {
+    READY: "READY",
+    RUNNING: "RUNNING",
+    COMPLETED: "COMPLETED"
+  },
+  FLOW_OPTIONS: {
+    delay: 0,
+    priority: 0,
+    between: null,
+    trigger: null,
+    condition: null,
+    beforeStart: null,
+    onComplete: null,
+    group: null,
+    paused: false,
+    preload: false,
+    fireEvents: true,
+    depends: []
+  },
+  EVENTS: {
+    STARTED: "QSL:started",
+    COMPLETED: "QSL:completed",
+    ERROR: "QSL:error",
+    FLOW_STARTED: "QSL:flow:started",
+    FLOW_COMPLETED: "QSL:flow:completed",
+    ALL_COMPLETED: "QSL:all:completed",
+    SKIPPED: "QSL:skipped",
+    DOMREADY: "QSL:domready",
+    LOADED: "QSL:loaded"
+  },
+  LIFECYCLE: {
+    DOMREADY: document.readyState === "interactive" || document.readyState === "complete",
+    LOADED: false
+  },
+  CALLBACK: "QSLReady",
+  /**
+   * Properties
+   */
+  types: /* @__PURE__ */ new Map(),
+  // Map to store custom resource types
+  flows: /* @__PURE__ */ new Map(),
+  // Map to store flows
+  flowOptions: /* @__PURE__ */ new Map(),
+  // Map to store flow options
+  flowGroups: /* @__PURE__ */ new Map(),
+  // Map to store flow groups
+  currentProcessPerFlow: /* @__PURE__ */ new Map(),
+  // Map to store current process per flow (flowId -> processId)
+  pendingFlows: /* @__PURE__ */ new Set(),
+  // Set to store pending flows
+  pendingProcesses: /* @__PURE__ */ new Set(),
+  // Set to store pending processes
+  completedProcesses: /* @__PURE__ */ new Set(),
+  // Set to store completed processes
+  loadActions: /* @__PURE__ */ new Set(),
+  // Set to store before load triggers
+  initActions: /* @__PURE__ */ new Set(),
+  // Set to store init triggers
+  addProcessFilters: /* @__PURE__ */ new Set(),
+  // Set to store add triggers
+  completedFlowsActions: /* @__PURE__ */ new Set(),
+  // Set to store completed flows actions
+  flowIdFilters: /* @__PURE__ */ new Set(),
+  // Set to store flowId filters
+  conditionHandlers: /* @__PURE__ */ new Set(),
+  // Set to store condition handlers
+  triggerHandlers: /* @__PURE__ */ new Set(),
+  // Set to store trigger handlers
+  processCompleteActions: /* @__PURE__ */ new Set(),
+  // Set to store process completion actions
+  allCompleteActions: /* @__PURE__ */ new Set(),
+  // Set to store all flows completion actions
+  resetActions: /* @__PURE__ */ new Set(),
+  // Set to store reset actions
+  handlerCallbacksFilters: /* @__PURE__ */ new Set(),
+  // Set to store handler callbacks filters
+  onAllComplete: null,
+  // Callback for all flows completion
+  globalResolve: null,
+  // Global resolve function
+  logger: null,
+  // Logger instance
+  hasStarted: false,
+  // Flag to check if QSL has started,
+  eventsEnabled: false,
+  // Flag to check if events are enabled
+  initialized: false,
+  // Flag to check if QSL is initialized
+  completing: false,
+  // Flag to check if QSL is completing
+  autoReset: true,
+  // Whether reset() runs automatically once every flow completes
+  globalBetween: 0,
+  // Global delay between processes
+  /**
+   * Initialize the QSL library.
+   * @returns {Promise<this>}
+   */
+  async init() {
+    if (this.initialized) return this;
+    window.__QSL__ = window.__QSL__ || this;
+    if (document.readyState === "interactive" || document.readyState === "complete") {
+      this.LIFECYCLE.DOMREADY = true;
+    } else {
+      document.addEventListener("DOMContentLoaded", () => this.LIFECYCLE.DOMREADY = true, { once: true });
+    }
+    if (document.readyState === "complete") {
+      this.LIFECYCLE.LOADED = true;
+    } else {
+      window.addEventListener("load", () => this.LIFECYCLE.LOADED = true, { once: true });
+    }
+    this.registerType("console", (process) => {
+      return new Promise((resolve) => {
+        var _a;
+        (_a = process.onBeforeStart) == null ? void 0 : _a.call(process);
+        setTimeout(() => {
+          var _a2;
+          if (process.message) this.log(process.message, { timestamp: Date.now() });
+          (_a2 = process.onComplete) == null ? void 0 : _a2.call(process);
+          resolve();
+        }, process.delay || 0);
+      });
+    });
+    window.addEventListener("QSL:log", (e) => this.log(e.detail.type, e.detail.config.id));
+    window.addEventListener("QSL:error", (e) => this.error(e.detail.type, e.detail.error, e.detail.config.id));
+    if (this.initActions.size) {
+      for (const cb of this.initActions) {
+        if (typeof cb === "function") await cb.call(this);
+      }
+    }
+    this.initialized = true;
+    const url = document.currentScript ? new URL(document.currentScript.src, document.baseURI) : null;
+    if (!url || url.searchParams.get("async") !== "true") return this;
+    const callback = url.searchParams.get("callback") || this.CALLBACK;
+    if (typeof window[callback] === "function") window[callback]();
+    return this;
+  },
+  /**
+   * Register a plugin to QSL.
+   *
+   * @param {Function} plugin - The plugin function to register.
+   * @param {...any} args - Additional arguments passed to the plugin.
+   * @returns {this}
+   */
+  use(plugin, ...args) {
+    if (typeof plugin === "function") plugin(this, ...args);
+    return this;
+  },
+  /**
+   * Add a process config to a flow.
+   * Handles process-level dependencies separately from flow-level logic.
+   *
+   * @param {Object} config - The process configuration object.
+   * @param {string|boolean|null} [flowId=null] - The flow ID or true for ordered, or null for default.
+   * @returns {this}
+   */
+  add(config, flowId = null) {
+    if (!config || typeof config !== "object") return this;
+    config.id = config.id ? this.PREFIX + config.id : this.PREFIX + Math.random().toString(36).slice(2);
+    config.skipped = false;
+    if (!config.type) config.type = "console";
+    if (Array.isArray(config.depends)) config.depends = [...new Set(config.depends)];
+    if (this.addProcessFilters.size) {
+      for (const cb of this.addProcessFilters) {
+        if (typeof cb === "function") [flowId, config] = cb.call(this, flowId, config);
+      }
+    }
+    const normalizedFlowId = this.normalizeFlowId(flowId);
+    config.flowId = normalizedFlowId;
+    this.getOrCreateFlow(normalizedFlowId).push(config);
+    return this;
+  },
+  /**
+   * Start loading all flows.
+   *
+   * @param {Object} [options={}]
+   * @param {number|boolean} [options.between=false] - Global delay between processes.
+   * @returns {Promise<this>}
+   */
+  async load({ between = false } = {}) {
+    if (this.hasStarted) return;
+    this.hasStarted = true;
+    this.globalBetween = between;
+    for (const cb of this.loadActions) {
+      if (typeof cb === "function") cb.call(this);
+    }
+    return new Promise((resolve) => {
+      if (!this.flows.size) {
+        this.reset();
+        return resolve();
+      }
+      this.globalResolve = resolve;
+      this.processFlows();
+    });
+  },
+  /**
+   * Reset all internal state and clear all flows/options.
+   * 
+   * @returns {void}
+   */
+  reset() {
+    if (this.resetActions.size) {
+      for (const action of this.resetActions) {
+        if (typeof action === "function") action.call(this);
+      }
+    }
+    this.flows.clear();
+    this.flowOptions.clear();
+    this.flowGroups.clear();
+    this.pendingFlows.clear();
+    this.pendingProcesses.clear();
+    this.completedProcesses.clear();
+    this.currentProcessPerFlow.clear();
+    this.onAllComplete = null;
+    this.globalResolve = null;
+    this.hasStarted = false;
+    this.globalBetween = 0;
+    this.log("RESET");
+    return this;
+  },
+  /**
+   * Tear the instance down completely: run state, plugin registrations and
+   * registered types. After this, init() has to run again.
+   *
+   * @returns {this}
+   */
+  destroy() {
+    this.reset();
+    this.types.clear();
+    this.initActions.clear();
+    this.loadActions.clear();
+    this.addProcessFilters.clear();
+    this.completedFlowsActions.clear();
+    this.flowIdFilters.clear();
+    this.conditionHandlers.clear();
+    this.triggerHandlers.clear();
+    this.processCompleteActions.clear();
+    this.allCompleteActions.clear();
+    this.resetActions.clear();
+    this.handlerCallbacksFilters.clear();
+    this.logger = null;
+    this.eventsEnabled = false;
+    this.initialized = false;
+    return this;
+  },
+  /**
+   * Set the logger instance.
+   *
+   * @param {Object|Function} logger - Logger instance or function.
+   * @returns {this}
+   */
+  setLogger(logger2) {
+    if (logger2 && (typeof logger2 === "function" || typeof logger2 === "object")) this.logger = logger2;
+    return this;
+  },
+  /**
+   * Set a callback to run when all flows/processes are complete.
+   *
+   * @param {Function} callback - The callback function.
+   * @returns {this}
+   */
+  setOnAllComplete(callback) {
+    this.onAllComplete = typeof callback === "function" ? callback : null;
+    return this;
+  },
+  /**
+   * Enable DOM events for process/flow lifecycle.
+   * @returns {this}
+   */
+  useEvents() {
+    this.eventsEnabled = true;
+    return this;
+  },
+  /**
+   * Log a message using the custom logger if set.
+   *
+   * @param {string} type - Log type.
+   * @param {...any} args - Additional log arguments.
+   */
+  log(type, ...args) {
+    if (this.logger && typeof this.logger.log === "function") this.logger.log(type, ...args);
+  },
+  /**
+   * Log an error using the custom logger if set.
+   * 
+   * @param {string} type - Error type.
+   * @param {...any} args - Additional error arguments.
+   */
+  error(type, ...args) {
+    if (this.logger && typeof this.logger.error === "function") this.logger.error(type, ...args);
+  },
+  /**
+   * Fire a DOM event if events are enabled.
+   * 
+   * @param {string} event - Event name.
+   * @param {Object} detail - Event detail object.
+   */
+  fire(event, detail) {
+    if (this.eventsEnabled && this.EVENTS[event]) {
+      window.dispatchEvent(new CustomEvent(this.EVENTS[event], { detail }));
+    }
+  },
+  /**
+   * Normalize the flow ID.
+   * 
+   * @param {string|boolean|null} flowId - The flow ID or true for ordered, or null for default.
+   * @returns {string} Normalized flow ID.
+   */
+  normalizeFlowId(flowId) {
+    if (flowId === true) {
+      flowId = this.FLOW_TYPE.ORDERED;
+    } else if (typeof flowId !== "string") {
+      flowId = this.FLOW_TYPE.DEFAULT;
+    }
+    return flowId;
+  },
+  /**
+   * Register a custom resource type handler.
+   *
+   * @param {string} type - Resource type name.
+   * @param {Function} handler - Handler function for the type.
+   * @returns {this}
+   */
+  registerType(type, handler) {
+    if (typeof type !== "string" || typeof handler !== "function") return this;
+    this.types.set(type, handler);
+    return this;
+  },
+  /**
+   * Register multiple custom resource types.
+   *
+   * @param {Array<{type: string, handler: Function}>|Object} types - Array or object of type definitions.
+   * @returns {this}
+   */
+  registerTypes(types) {
+    if (!types || typeof types !== "object") return this;
+    const list = Array.isArray(types) ? types : Object.entries(types).map(([type, handler]) => typeof handler === "function" ? { type, handler } : handler);
+    for (const type of list) {
+      if (type) this.registerType(type.type, type.handler);
+    }
+    return this;
+  },
+  /**
+   * Pause all flows in a group.
+   * 
+   * @param {string} group - Group name.
+   * @returns {this}
+   */
+  pauseGroup(group) {
+    const flowGroup = this.flowGroups.get(group);
+    if (!flowGroup) return this;
+    for (const flowId of flowGroup) {
+      this.setFlowOptions({ paused: true }, flowId);
+    }
+    return this;
+  },
+  /**
+   * Run all flows in a group.
+   * 
+   * @param {string} group - Group name.
+   * @returns {this}
+   */
+  runGroup(group) {
+    const flowGroup = this.flowGroups.get(group);
+    if (!flowGroup) return this;
+    for (const flowId of flowGroup) {
+      this.setFlowOptions({ paused: false }, flowId);
+      this.runFlow(flowId);
+    }
+    return this;
+  },
+  /**
+   * Run a specific flow by id.
+   *
+   * @param {string} flowId - Flow ID.
+   * @param {boolean} [withTrigger=false] - Whether to run with trigger logic.
+   * @returns {this}
+   */
+  runFlow(flowId, withTrigger = false) {
+    const processes = this.flows.get(flowId);
+    const options = this.flowOptions.get(flowId);
+    if (!processes || !options || options.status !== this.FLOW_STATE.READY) return this;
+    this.processFlows(flowId, withTrigger);
+    return this;
+  },
+  /**
+   * Get or create a flow.
+   * 
+   * @param {string} flowId - Flow ID.
+   * @returns {Array} The flow's process array.
+   */
+  getOrCreateFlow(flowId) {
+    if (!this.flows.has(flowId)) {
+      this.flows.set(flowId, []);
+      this.flowOptions.set(flowId, {
+        ...this.FLOW_OPTIONS,
+        ordered: flowId === this.FLOW_TYPE.ORDERED,
+        status: this.FLOW_STATE.READY
+      });
+    }
+    return this.flows.get(flowId);
+  },
+  /**
+   * Set or update options for a flow.
+   * If depends is set, pauses the flow until dependencies are resolved.
+   * 
+   * @param {Object} options - Flow options.
+   * @param {string|boolean|null} [flowId=null] - Flow ID.
+   * @returns {this}
+   */
+  setFlowOptions(options = {}, flowId = null) {
+    flowId = this.normalizeFlowId(flowId);
+    this.getOrCreateFlow(flowId);
+    if (!options || typeof options !== "object") return this;
+    const prevOptions = this.flowOptions.get(flowId);
+    if (Array.isArray(options.depends) && options.depends.length) {
+      options.depends = [...new Set(options.depends)];
+      options.paused = true;
+      this.pendingFlows.add(flowId);
+    }
+    if (options.group) {
+      if (!this.flowGroups.has(options.group)) this.flowGroups.set(options.group, /* @__PURE__ */ new Set());
+      this.flowGroups.get(options.group).add(flowId);
+    }
+    this.flowOptions.set(flowId, { ...prevOptions, ...options });
+    return this;
+  },
+  /**
+   * Check all pending flows and run those whose dependencies are now resolved.
+   * 
+   * @returns {void}
+   */
+  checkPendingFlows() {
+    if (!this.pendingFlows.size) return;
+    for (const pendingFlowId of this.pendingFlows) {
+      const pendingOptions = this.flowOptions.get(pendingFlowId);
+      if (pendingOptions && pendingOptions.depends && pendingOptions.depends.every((depId) => {
+        const depOpt = this.flowOptions.get(this.normalizeFlowId(depId));
+        return depOpt && depOpt.status === this.FLOW_STATE.COMPLETED;
+      })) {
+        this.setFlowOptions({ paused: false }, pendingFlowId);
+        this.pendingFlows.delete(pendingFlowId);
+        this.runFlow(pendingFlowId);
+      }
+    }
+  },
+  /**
+   * Check all pending processes and run those whose dependencies are now resolved.
+   * 
+   * @returns {void}
+   */
+  checkPendingProcesses() {
+    if (!this.pendingProcesses.size) return;
+    for (const process of this.pendingProcesses) {
+      const missingDeps = process.depends.filter((depId) => {
+        const hasProcess = Array.from(this.flows.values()).some(
+          (flow) => flow.some((p) => p.id === this.PREFIX + depId)
+        );
+        return !this.completedProcesses.has(this.PREFIX + depId) && !hasProcess;
+      });
+      if (missingDeps.length) {
+        this.pendingProcesses.delete(process);
+        this.log("DEP_NOT_FOUND", process.id, `${missingDeps.join(", ")}`);
+        process._depsResolved = true;
+        process._triggered = true;
+        if (process._waitResolve) process._waitResolve();
+        continue;
+      }
+      const allDepsCompleted = process.depends.every((depId) => this.completedProcesses.has(this.PREFIX + depId));
+      if (allDepsCompleted) {
+        this.pendingProcesses.delete(process);
+        process._depsResolved = true;
+        if (process._triggered && process._waitResolve) process._waitResolve();
+      }
+    }
+  },
+  /**
+   * Check if all flows/processes are complete and resolve global promise if so.
+   * 
+   * @returns {Promise<void>}
+   */
+  async maybeComplete() {
+    var _a;
+    if (!this.hasStarted) return;
+    if (this.pendingFlows.size) {
+      for (const pendingFlowId of this.pendingFlows) {
+        const pendingOptions = this.flowOptions.get(pendingFlowId);
+        if (pendingOptions && pendingOptions.depends && pendingOptions.depends.some((depId) => !this.flowOptions.has(this.normalizeFlowId(depId)))) {
+          this.setFlowOptions({ status: this.FLOW_STATE.COMPLETED }, pendingFlowId);
+          this.pendingFlows.delete(pendingFlowId);
+          this.log("FLOW_DEP_SKIPPED", { flow: pendingFlowId, depends: `${pendingOptions.depends.filter((depId) => !this.flowOptions.has(this.normalizeFlowId(depId))).join(", ")}` });
+        }
+      }
+    }
+    let flowsDone = this.flowOptions.size ? Array.from(this.flowOptions.values()).every((opt) => opt.status === this.FLOW_STATE.COMPLETED) : false;
+    if (!flowsDone) return;
+    let maybeComplete = true;
+    if (this.flows.size && this.completedFlowsActions.size) {
+      for (const cb of this.completedFlowsActions) {
+        maybeComplete = cb.call(this, flowsDone, this.flows, this.flowOptions);
+      }
+    }
+    if (!maybeComplete) return;
+    if (this.completing) return;
+    this.completing = true;
+    this.log("ALL_COMPLETED");
+    this.fire("ALL_COMPLETED");
+    (_a = this.onAllComplete) == null ? void 0 : _a.call(this);
+    if (this.globalResolve !== null) this.globalResolve();
+    if (this.allCompleteActions.size) {
+      for (const action of this.allCompleteActions) {
+        if (typeof action === "function") action.call(this);
+      }
+    }
+    if (this.autoReset) this.reset();
+    this.completing = false;
+  },
+  /**
+   * Process all flows and their dependencies.
+   * 
+   * @param {string|null} [flowId=null] - Specific flow ID or null for all.
+   * @param {boolean} [withTrigger=false] - Whether to run with trigger logic.
+   * @returns {this}
+   */
+  processFlows(flowId = null, withTrigger = false) {
+    if (!this.flows.size) return;
+    let flowIds = flowId ? [flowId] : Array.from(this.flows.keys());
+    if (flowIds.length && this.flowIdFilters.size) {
+      for (const cb of this.flowIdFilters) {
+        if (typeof cb === "function") flowIds = cb.call(this, flowIds);
+      }
+    }
+    flowIds.sort((a, b) => {
+      const aOpts = this.flowOptions.get(a);
+      const bOpts = this.flowOptions.get(b);
+      const aHasTrigger = (aOpts == null ? void 0 : aOpts.trigger) != null;
+      const bHasTrigger = (bOpts == null ? void 0 : bOpts.trigger) != null;
+      if (aHasTrigger && !bHasTrigger) return 1;
+      if (!aHasTrigger && bHasTrigger) return -1;
+      const aPriority = (aOpts == null ? void 0 : aOpts.priority) || 0;
+      const bPriority = (bOpts == null ? void 0 : bOpts.priority) || 0;
+      return bPriority - aPriority;
+    });
+    for (const fid of flowIds) {
+      const options = this.flowOptions.get(fid);
+      if (!options || options.status === this.FLOW_STATE.COMPLETED) continue;
+      if (this.getConditionStatus(options.condition)) {
+        this.setFlowOptions({ status: this.FLOW_STATE.COMPLETED }, fid);
+        continue;
+      }
+      if (options.paused) continue;
+      if (flowId === null || flowId && !withTrigger) {
+        if (options.trigger != null) {
+          const trigger = this.getTriggerFunction(options.trigger, options);
+          if (trigger) {
+            this.setFlowOptions({ paused: true }, fid);
+            let triggered = false;
+            trigger(() => {
+              if (triggered) return;
+              triggered = true;
+              this.setFlowOptions({ paused: false }, fid);
+              this.runFlow(fid, true);
+            });
+            continue;
+          }
+        }
+      }
+      this.setFlowOptions({ status: this.FLOW_STATE.RUNNING }, fid);
+      (async () => {
+        var _a, _b;
+        (_a = options.beforeStart) == null ? void 0 : _a.call(options);
+        if (options.delay && options.delay > 0) {
+          await new Promise((res) => setTimeout(res, options.delay));
+        }
+        const processes = (this.flows.get(fid) || []).slice();
+        processes.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+        if ((options.preload || options.prefetch) && !options.trigger) {
+          for (const p of processes) {
+            if (p.trigger) continue;
+            if (p.type === "script" && p.src || p.type === "style" && p.href) {
+              try {
+                const link = document.createElement("link");
+                link.rel = options.preload ? "preload" : "prefetch";
+                link.href = p.src || p.href;
+                link.as = p.type === "script" ? "script" : "style";
+                if (p.crossOrigin) link.crossOrigin = p.crossOrigin;
+                document.head.appendChild(link);
+              } catch (e) {
+                this.error("PRELOAD_ERROR", e, p.id);
+              }
+            }
+          }
+        }
+        const between = options.between !== void 0 && options.between !== null ? options.between : this.globalBetween;
+        if (options.ordered) {
+          let prev = Promise.resolve();
+          processes.forEach((process, idx) => {
+            prev = prev.then(async () => {
+              if (idx > 0 && between) await new Promise((res) => setTimeout(res, between));
+              await this.run(process);
+            });
+          });
+          await prev;
+        } else {
+          const promises = processes.map(async (process, idx) => {
+            if (idx > 0 && between) await new Promise((res) => setTimeout(res, between));
+            return this.run(process);
+          });
+          await Promise.all(promises);
+        }
+        this.setFlowOptions({ status: this.FLOW_STATE.COMPLETED }, fid);
+        (_b = options.onComplete) == null ? void 0 : _b.call(options);
+        this.checkPendingFlows();
+        this.maybeComplete();
+      })();
+    }
+    this.checkPendingFlows();
+    this.maybeComplete();
+  },
+  /**
+   * Execute a process based on its type.
+   * 
+   * @param {Object} process - The process object.
+   * @returns {Promise<any>}
+   */
+  async run(process) {
+    if (process._running || this.getConditionStatus(process.condition)) return;
+    process._running = true;
+    if (!process._waitPromise) {
+      process._triggered = false;
+      process._depsResolved = false;
+      process._waitPromise = new Promise((res) => process._waitResolve = res);
+    }
+    if (process.trigger != null) {
+      const trigger = this.getTriggerFunction(process.trigger, process);
+      if (trigger) {
+        trigger(() => {
+          process._triggered = true;
+          if (process._depsResolved) process._waitResolve();
+        });
+      } else {
+        process._triggered = true;
+      }
+    } else {
+      process._triggered = true;
+    }
+    if (Array.isArray(process.depends) && process.depends.length) {
+      const missingDeps = process.depends.filter((depId) => {
+        const hasProcess = Array.from(this.flows.values()).some(
+          (flow) => flow.some((p) => p.id === this.PREFIX + depId)
+        );
+        return !this.completedProcesses.has(this.PREFIX + depId) && !hasProcess;
+      });
+      if (missingDeps.length) {
+        this.log("DEP_NOT_FOUND", process.id, `${missingDeps.join(", ")}`);
+        process._depsResolved = true;
+        process._triggered = true;
+        if (process._waitResolve) process._waitResolve();
+      } else {
+        const allDepsCompleted = process.depends.every((depId) => this.completedProcesses.has(this.PREFIX + depId));
+        if (!allDepsCompleted) {
+          this.pendingProcesses.add(process);
+        } else {
+          process._depsResolved = true;
+          if (process._triggered) process._waitResolve();
+        }
+      }
+    } else {
+      process._depsResolved = true;
+      if (process._triggered) process._waitResolve();
+    }
+    await process._waitPromise;
+    return this.execute(process);
+  },
+  /**
+   * Check the condition option and return true if the condition fails.
+   * 
+   * @param {string|Function|boolean} conditionOption - The condition option.
+   * @returns {boolean} True if the condition fails, false otherwise.
+   */
+  getConditionStatus(opt) {
+    if (opt == null) return false;
+    if (Array.isArray(opt)) {
+      return opt.some((c) => this.getConditionStatus(c));
+    }
+    if (typeof opt === "object" && opt.operator) {
+      const { operator, conditions: conditions2 } = opt;
+      if (!Array.isArray(conditions2)) return false;
+      if (operator === "or") {
+        return conditions2.every((c) => this.getConditionStatus(c));
+      } else if (operator === "and") {
+        return conditions2.some((c) => this.getConditionStatus(c));
+      }
+      return false;
+    }
+    if (typeof opt === "function" && !opt()) return true;
+    if (typeof opt === "boolean" && !opt) return true;
+    if (this.conditionHandlers.size) {
+      for (const h of this.conditionHandlers) {
+        if (typeof h === "function") {
+          const r = h.call(this, opt);
+          if (r === true || r === false) return r;
+        }
+      }
+    }
+    return false;
+  },
+  /**
+   * Parse and return a trigger function based on the trigger option.
+   * 
+   * @param {string|Function|boolean} opt - The trigger option.
+   * @param {Object} o - The associated process or flow object.
+   * @returns {Function|null} The trigger function or null if no trigger function is found.
+   */
+  getTriggerFunction(opt, o) {
+    if (opt == null) return null;
+    if (typeof opt === "function") {
+      return (cb) => opt(cb);
+    }
+    if (Array.isArray(opt)) {
+      return (cb) => {
+        const vd = opt.map((t) => this.getTriggerFunction(t, o)).filter((tF) => tF);
+        if (vd.length === 0) {
+          cb();
+          return;
+        }
+        let f = 0;
+        const fCb = () => {
+          if (++f === vd.length) cb();
+        };
+        vd.forEach((tF) => tF(fCb));
+      };
+    }
+    if (typeof opt === "object" && opt.operator) {
+      const { operator, triggers: triggers2 } = opt;
+      if (!Array.isArray(triggers2)) return null;
+      if (operator === "or") {
+        return (cb) => {
+          const vd = triggers2.map((t) => this.getTriggerFunction(t, o)).filter((tF) => tF);
+          if (vd.length === 0) {
+            cb();
+            return;
+          }
+          let f = false;
+          const fCb = () => {
+            if (!f) {
+              f = true;
+              cb();
+            }
+          };
+          vd.forEach((tF) => tF(fCb));
+        };
+      } else if (operator === "and") {
+        return (cb) => {
+          const vd = triggers2.map((t) => this.getTriggerFunction(t, o)).filter((tF) => tF);
+          if (vd.length === 0) {
+            cb();
+            return;
+          }
+          let f = 0;
+          const fCb = () => {
+            if (++f === vd.length) cb();
+          };
+          vd.forEach((tF) => tF(fCb));
+        };
+      }
+      return null;
+    }
+    if (this.triggerHandlers.size) {
+      for (const h of this.triggerHandlers) {
+        if (typeof h === "function") {
+          const r = h.call(this, opt, o);
+          if (r && typeof r === "function") return r;
+        }
+      }
+    }
+    if (opt === true || opt === "interaction") {
+      return (cb) => this.waitForInteraction(cb);
+    }
+    return null;
+  },
+  /**
+   * Wait for user interaction before running a callback (for interaction phase).
+   * This is the default fallback trigger.
+   * 
+   * @param {Function} cb - The callback to run after user interaction.
+   * @returns {void}
+   */
+  waitForInteraction(cb) {
+    ["click", "keydown", "wheel", "mousedown", "mousemove", "touchstart"].forEach((e) => window.addEventListener(e, () => cb(), { once: true, passive: true }));
+  },
+  /**
+   * Execute the process based on its type.
+   * 
+   * @param {Object} process - The process object.
+   * @returns {Promise<any>}
+   */
+  async execute(process) {
+    const finishProcess = async () => {
+      if (this.processCompleteActions.size) {
+        for (const action of this.processCompleteActions) {
+          if (typeof action === "function") action.call(this, process);
+        }
+      }
+      this.completedProcesses.add(process.id);
+      process._running = false;
+      this.checkPendingProcesses();
+    };
+    if (process.skipped) {
+      this.fire("SKIPPED", { ...process, id: process.id });
+      finishProcess();
+      return;
+    }
+    const handler = this.types.get(process.type);
+    if (!handler) {
+      this.log("UNKNOWN_TYPE", process.type, process.id);
+      finishProcess();
+      return;
+    }
+    this.fire("STARTED", { ...process, id: process.id });
+    const callbacks = {};
+    if (this.handlerCallbacksFilters.size) {
+      for (const filter of this.handlerCallbacksFilters) {
+        if (typeof filter === "function") {
+          const pluginCallbacks = filter.call(this, process);
+          if (pluginCallbacks && typeof pluginCallbacks === "object") {
+            Object.assign(callbacks, pluginCallbacks);
+          }
+        }
+      }
+    }
+    return handler(process, callbacks).then(() => {
+      this.fire("COMPLETED", { ...process, id: process.id });
+      finishProcess();
+    }).catch(() => {
+      this.fire("ERROR", { ...process, id: process.id });
+      finishProcess();
+    });
+  }
+};
+const bypassSuffix = (source, bypassCache) => {
+  return bypassCache ? (source.includes("?") ? "&" : "?") + Date.now() : "";
+};
+const log = (detail) => {
+  window.dispatchEvent(new CustomEvent("QSL:log", { detail }));
+};
+const error = (detail) => {
+  window.dispatchEvent(new CustomEvent("QSL:error", { detail }));
+};
+const render = (config, callbacks = {}) => {
+  return new Promise(async (resolve) => {
+    var _a;
+    const { flowId, tag, id, delay, data, onBeforeStart, onComplete, onError, footer, dom, onElement, onCustomResolve } = config;
+    if (!flowId || !tag || !id) {
+      resolve();
+      return;
+    }
+    try {
+      if (onBeforeStart) await onBeforeStart(config);
+      log({ tag, type: "PROCESS_STARTED", config });
+      if (delay) await new Promise((res) => setTimeout(res, delay));
+      let el = document.createElement(tag);
+      onElement == null ? void 0 : onElement(el, config);
+      (_a = callbacks.registerProcessElement) == null ? void 0 : _a.call(callbacks, el, config);
+      if (data && typeof data === "object") {
+        for (const [key, value] of Object.entries(data)) {
+          el.setAttribute(`data-${key.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/[^a-z0-9_-]/g, "").replace(/^-/, "")}`, String(value));
+        }
+      }
+      if (!onCustomResolve) {
+        el.onload = () => {
+          log({ tag, type: "PROCESS_COMPLETED", config });
+          onComplete == null ? void 0 : onComplete();
+          resolve();
+        };
+      }
+      el.onerror = (e) => {
+        error({ tag, type: "PROCESS_FAILED", config });
+        onError == null ? void 0 : onError(e);
+        resolve(e);
+      };
+      if (dom) {
+        (footer ? document.body : document.head).appendChild(el);
+      }
+      onCustomResolve == null ? void 0 : onCustomResolve({ el, config, resolve });
+    } catch (e) {
+      error({ tag, type: "PROCESS_FAILED", config, error: e });
+      onError == null ? void 0 : onError(e);
+      resolve(e);
+    }
+  });
+};
+const InlineScript = {
+  type: "inline-script",
+  handler: (config, callbacks) => {
+    var _a;
+    let storedResolve = null;
+    let alreadyFired = false;
+    const eventName = `QSL:inline-script:completed:${config.id}`;
+    const resolveProcess = () => {
+      var _a2;
+      log({ tag: "inline-script", type: "INLINE_SCRIPT_SUCCESS", config });
+      log({ tag: "inline-script", type: "PROCESS_COMPLETED", config });
+      (_a2 = config == null ? void 0 : config.onComplete) == null ? void 0 : _a2.call(config);
+      storedResolve == null ? void 0 : storedResolve();
+    };
+    const normalizedConfig = {
+      ...config,
+      code: (_a = config.code) == null ? void 0 : _a.replace(/<script.*?>|<\/script>/gi, "")
+    };
+    return render({
+      ...normalizedConfig,
+      tag: "script",
+      dom: true,
+      onElement: (el, config2) => {
+        const { code, module, id, flowId } = config2;
+        if (code) el.textContent = code;
+        if (module) {
+          el.type = "module";
+          const originalCode = el.textContent;
+          const fid = JSON.stringify(String(flowId));
+          const pid = JSON.stringify(String(id));
+          const evt = JSON.stringify(String(eventName));
+          const wrappedCode = `(function(){window.__QSL__.currentProcessPerFlow.set(${fid},${pid});try{${originalCode}}finally{window.__QSL__.currentProcessPerFlow.delete(${fid});window.dispatchEvent(new Event(${evt}));}})();`;
+          el.textContent = wrappedCode;
+          const handler = () => {
+            window.removeEventListener(eventName, handler);
+            if (storedResolve) {
+              resolveProcess();
+            } else {
+              alreadyFired = true;
+            }
+          };
+          window.addEventListener(eventName, handler);
+        }
+      },
+      onCustomResolve: ({ el, config: config2, resolve }) => {
+        const { module } = config2;
+        storedResolve = resolve;
+        if (module && alreadyFired) {
+          resolveProcess();
+        } else if (!module) {
+          queueMicrotask(() => {
+            if (storedResolve === resolve) resolveProcess();
+          });
+        }
+      }
+    }, callbacks);
+  }
+};
+const Script = {
+  type: "script",
+  handler: (config, callbacks) => {
+    return render({
+      ...config,
+      tag: "script",
+      dom: true,
+      onElement: (el, { src, module, async, defer, crossOrigin, integrity, bypassCache }) => {
+        if (module) el.type = "module";
+        if (async) el.async = async;
+        if (defer) el.defer = defer;
+        if (crossOrigin) el.crossOrigin = crossOrigin;
+        if (integrity) el.integrity = integrity;
+        if (src) el.src = src + bypassSuffix(src, bypassCache);
+      }
+    }, callbacks);
+  }
+};
+const InlineStyle = {
+  type: "style",
+  handler: (config, callbacks) => {
+    var _a;
+    const normalizedConfig = {
+      ...config,
+      code: (_a = config.code) == null ? void 0 : _a.replace(/<style.*?>|<\/style>/gi, "")
+    };
+    return render({
+      ...normalizedConfig,
+      tag: "style",
+      dom: true,
+      onElement: (el, { code }) => {
+        if (code) el.textContent = code;
+      },
+      onCustomResolve: ({ el, config: config2, resolve }) => {
+        const { tag, onComplete } = config2;
+        log({ tag, type: "INLINE_STYLE_SUCCESS", config: config2 });
+        log({ tag, type: "PROCESS_COMPLETED", config: config2 });
+        onComplete == null ? void 0 : onComplete();
+        resolve();
+      }
+    }, callbacks);
+  }
+};
+const Stylesheet = {
+  type: "stylesheet",
+  handler: (config, callbacks) => {
+    return render({
+      ...config,
+      tag: "link",
+      dom: true,
+      onElement: (el, { href, crossOrigin, bypassCache }) => {
+        el.rel = "stylesheet";
+        if (crossOrigin) el.crossOrigin = crossOrigin;
+        el.href = href + bypassSuffix(href, bypassCache);
+      }
+    }, callbacks);
+  }
+};
+const Pixel = {
+  type: "pixel",
+  handler: (config, callbacks) => {
+    return render({
+      ...config,
+      tag: "img",
+      dom: true,
+      onElement: (el, { style = { display: "none" }, dom, src, bypassCache }) => {
+        if (!dom) el = new window.Image();
+        el.src = src + bypassSuffix(src, bypassCache);
+        el.width = 1;
+        el.height = 1;
+        if (style && typeof style === "object") {
+          for (const [key, value] of Object.entries(style)) {
+            el.style.setProperty(key, value);
+          }
+        }
+      },
+      onCustomResolve: ({ el, config: config2, resolve }) => {
+        const { tag, dom, onComplete } = config2;
+        const resolver = () => {
+          log({ tag, type: "IMAGE_LOADED", config: config2 });
+          log({ tag, type: "PROCESS_COMPLETED", config: config2 });
+          onComplete == null ? void 0 : onComplete();
+          resolve();
+        };
+        !dom ? resolver() : el.onload = () => resolver();
+      }
+    }, callbacks);
+  }
+};
+const Shadow = {
+  type: "shadow",
+  handler: (config, callbacks) => {
+    return render({
+      ...config,
+      onBeforeStart: async ({ tag }) => await window.customElements.whenDefined(tag),
+      onElement: (el, { shadowData }) => {
+        el.data = shadowData || {};
+        if (shadowData == null ? void 0 : shadowData.hidden) el.setAttribute("hidden", "");
+      },
+      onCustomResolve: ({ el, config: config2, resolve }) => {
+        const { tag, shadowData, onComplete, onError } = config2;
+        const resolver = () => {
+          const selector = shadowData == null ? void 0 : shadowData.container;
+          let container = null;
+          if (selector === "body") {
+            container = document.body;
+          } else if (typeof selector === "string" && selector) {
+            try {
+              container = document.querySelector(selector);
+            } catch (e) {
+              container = null;
+            }
+          }
+          if (!container) {
+            const err = new Error(`Container not found: ${selector}`);
+            error({ tag, type: "SHADOW_FAILED", config: config2, error: err });
+            onError == null ? void 0 : onError(err);
+            resolve(err);
+            return;
+          }
+          (shadowData == null ? void 0 : shadowData.position) === "top" ? container.insertBefore(el, container.firstChild) : container.appendChild(el);
+          log({ tag, type: "SHADOW_SUCCESS", config: config2 });
+          log({ tag, type: "PROCESS_COMPLETED", config: config2 });
+          onComplete == null ? void 0 : onComplete();
+          resolve();
+        };
+        if (document.readyState === "interactive" || document.readyState === "complete") {
+          resolver();
+        } else {
+          document.addEventListener("DOMContentLoaded", resolver, { once: true });
+        }
+      }
+    }, callbacks);
+  }
+};
+const HTML = {
+  type: "html",
+  handler: (config, callbacks) => {
+    return render({
+      ...config,
+      dom: true,
+      onElement: (el, { html = "", id = "", className = "", style = {} }) => {
+        if (html) el.innerHTML = html;
+        if (id) el.id = id;
+        if (className) el.className = Array.isArray(className) ? className.join(" ") : className;
+        if (style && typeof style === "object") {
+          for (const [key, value] of Object.entries(style)) {
+            el.style.setProperty(key, value);
+          }
+        }
+      },
+      onCustomResolve: ({ el, config: config2, resolve }) => {
+        const { tag, onComplete } = config2;
+        log({ tag, type: "HTML_SUCCESS", config: config2 });
+        log({ tag, type: "PROCESS_COMPLETED", config: config2 });
+        onComplete == null ? void 0 : onComplete();
+        resolve();
+      }
+    }, callbacks);
+  }
+};
+function mediaQueryCondition(QSL) {
+  QSL.conditionHandlers.add(function(opt) {
+    if (typeof opt !== "string" || !opt.startsWith("media:")) {
+      return null;
+    }
+    return !window.matchMedia(opt.slice("media:".length)).matches;
+  });
+}
+function languageCondition(QSL) {
+  QSL.conditionHandlers.add(function(opt) {
+    var _a;
+    if (typeof opt !== "string" || !opt.startsWith("lang:")) {
+      return null;
+    }
+    const p = opt.split(":");
+    const t = p[1] || "equals";
+    const v = p.slice(2).join(":");
+    const l = navigator.language || ((_a = navigator.languages) == null ? void 0 : _a[0]) || "";
+    switch (t) {
+      case "equals":
+      case "is":
+        return l !== v;
+      case "contains":
+        return !l.includes(v);
+      case "startsWith":
+        return !l.startsWith(v);
+      case "in":
+        const ls = v.split(",").map((ll) => ll.trim());
+        return !ls.includes(l);
+      default:
+        return true;
+    }
+  });
+}
+function timezoneCondition(QSL) {
+  QSL.conditionHandlers.add(function(opt) {
+    if (typeof opt !== "string" || !opt.startsWith("tz:") && !opt.startsWith("timezone:")) {
+      return null;
+    }
+    const p = opt.split(":");
+    const t = p[1] || "equals";
+    const v = p.slice(2).join(":");
+    try {
+      const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+      const o = -(/* @__PURE__ */ new Date()).getTimezoneOffset() / 60;
+      switch (t) {
+        case "equals":
+        case "is":
+          return tz !== v;
+        case "contains":
+          return !tz.includes(v);
+        case "offset":
+          return o !== parseInt(v);
+        default:
+          return true;
+      }
+    } catch (e) {
+      return true;
+    }
+  });
+}
+function urlCondition(QSL) {
+  QSL.conditionHandlers.add(function(opt) {
+    if (typeof opt !== "string" || !opt.startsWith("url:")) {
+      return null;
+    }
+    const lc = window.location;
+    const hf = lc.href;
+    const pn = lc.pathname;
+    const se = lc.search;
+    const hn = lc.hostname;
+    const p = opt.split(":");
+    const t = p[1];
+    const v = p.slice(2).join(":");
+    if (!t) return true;
+    switch (t) {
+      case "contains":
+        return !hf.includes(v);
+      case "path":
+        return !pn.includes(v);
+      case "pathStartsWith":
+        return !pn.startsWith(v);
+      case "pathEndsWith":
+        return !pn.endsWith(v);
+      case "query":
+        if (se) {
+          const q = new URLSearchParams(se);
+          if (v.includes("=")) {
+            const [key, val] = v.split("=");
+            return q.get(key) !== val;
+          } else {
+            return !q.has(v);
+          }
+        } else {
+          return true;
+        }
+      case "hostname":
+        return !hn.includes(v);
+      case "matches":
+        try {
+          return !new RegExp(v).test(hf);
+        } catch (e) {
+          return true;
+        }
+      case "pathMatches":
+        try {
+          return !new RegExp(v).test(pn);
+        } catch (e) {
+          return true;
+        }
+      default:
+        return true;
+    }
+  });
+}
+function userAgentCondition(QSL) {
+  QSL.conditionHandlers.add(function(opt) {
+    if (typeof opt !== "string" || !opt.startsWith("ua:") && !opt.startsWith("userAgent:")) {
+      return null;
+    }
+    const p = opt.split(":");
+    const t = p[1] || "contains";
+    const v = p.slice(2).join(":");
+    const ua = navigator.userAgent || "";
+    const uaLower = ua.toLowerCase();
+    const vLower = v.toLowerCase();
+    switch (t) {
+      case "contains":
+        if (!uaLower.includes(vLower)) return true;
+        break;
+      case "equals":
+      case "is":
+        if (ua !== v) return true;
+        break;
+      case "matches":
+        try {
+          if (!new RegExp(v, "i").test(ua)) return true;
+        } catch (e) {
+          return true;
+        }
+        break;
+      case "browser":
+        const bMap = {
+          "chrome": /chrome/i.test(ua) && !/edg|opr/i.test(ua),
+          "firefox": /firefox/i.test(ua),
+          "safari": /safari/i.test(ua) && !/chrome|chromium|edg|opr/i.test(ua),
+          "edge": /edg/i.test(ua),
+          "opera": /opr/i.test(ua),
+          "ie": /msie|trident/i.test(ua),
+          "chromium": /chromium/i.test(ua)
+        };
+        const bKey = vLower;
+        if (!bMap[bKey]) return true;
+        break;
+      case "device":
+        const isM = /mobile|android|iphone|ipod|blackberry|iemobile|opera mini/i.test(ua);
+        const isT = /tablet|ipad|playbook|silk/i.test(ua) || isM && /android/i.test(ua) && !/mobile/i.test(ua);
+        const isD = !isM && !isT;
+        switch (vLower) {
+          case "mobile":
+            if (!isM) return true;
+            break;
+          case "tablet":
+            if (!isT) return true;
+            break;
+          case "desktop":
+            if (!isD) return true;
+            break;
+          default:
+            return true;
+        }
+        break;
+      case "os":
+      case "platform":
+        const oMap = {
+          "windows": /win/i.test(ua),
+          "mac": /mac/i.test(ua),
+          "ios": /iphone|ipad|ipod/i.test(ua),
+          "android": /android/i.test(ua),
+          "linux": /linux/i.test(ua) && !/android/i.test(ua),
+          "unix": /unix/i.test(ua),
+          "chromeos": /cros/i.test(ua)
+        };
+        if (!oMap[vLower]) return true;
+        break;
+      default:
+        return true;
+    }
+    return false;
+  });
+}
+function conditions(QSL) {
+  mediaQueryCondition(QSL);
+  languageCondition(QSL);
+  timezoneCondition(QSL);
+  urlCondition(QSL);
+  userAgentCondition(QSL);
+}
+const arg = (opt, prefix) => opt.slice(prefix.length);
+const isPrefixed = (opt, prefix) => typeof opt === "string" && opt.startsWith(prefix);
+const whenElement = (selector, cb) => {
+  let el = null;
+  try {
+    el = document.querySelector(selector);
+  } catch (e) {
+    cb(null);
+    return;
+  }
+  if (el) {
+    cb(el);
+    return;
+  }
+  if (typeof MutationObserver !== "function") {
+    cb(null);
+    return;
+  }
+  const root = document.body || document.documentElement;
+  if (!root) {
+    cb(null);
+    return;
+  }
+  const observer = new MutationObserver(() => {
+    const found = document.querySelector(selector);
+    if (found) {
+      observer.disconnect();
+      cb(found);
+    }
+  });
+  observer.observe(root, { childList: true, subtree: true });
+};
+function loadTrigger(QSL) {
+  QSL.triggerHandlers.add(function(opt) {
+    if (opt !== "load") return null;
+    return (cb) => {
+      if (document.readyState === "complete") {
+        cb();
+      } else {
+        window.addEventListener("load", () => cb(), { once: true });
+      }
+    };
+  });
+}
+function idleTrigger(QSL) {
+  QSL.triggerHandlers.add(function(opt) {
+    if (opt !== "idle") return null;
+    return (cb) => {
+      if (typeof window.requestIdleCallback === "function") {
+        window.requestIdleCallback(() => cb());
+      } else {
+        setTimeout(() => cb(), 200);
+      }
+    };
+  });
+}
+function domReadyTrigger(QSL) {
+  QSL.triggerHandlers.add(function(opt) {
+    if (opt !== "domready") return null;
+    return (cb) => {
+      if (document.readyState === "interactive" || document.readyState === "complete") {
+        cb();
+      } else {
+        document.addEventListener("DOMContentLoaded", () => cb(), { once: true });
+      }
+    };
+  });
+}
+function delayTrigger(QSL) {
+  QSL.triggerHandlers.add(function(opt) {
+    if (!isPrefixed(opt, "delay:")) return null;
+    const ms = parseInt(arg(opt, "delay:"), 10);
+    return (cb) => setTimeout(cb, Number.isFinite(ms) && ms > 0 ? ms : 0);
+  });
+}
+function hoverTrigger(QSL) {
+  QSL.triggerHandlers.add(function(opt) {
+    if (!isPrefixed(opt, "hover:")) return null;
+    const selector = arg(opt, "hover:");
+    return (cb) => {
+      whenElement(selector, (el) => {
+        if (!el) {
+          cb();
+          return;
+        }
+        el.addEventListener("mouseenter", () => cb(), { once: true, passive: true });
+      });
+    };
+  });
+}
+function visibleTrigger(QSL) {
+  QSL.triggerHandlers.add(function(opt) {
+    if (!isPrefixed(opt, "visible:")) return null;
+    const selector = arg(opt, "visible:");
+    return (cb) => {
+      whenElement(selector, (el) => {
+        if (!el || typeof IntersectionObserver !== "function") {
+          cb();
+          return;
+        }
+        const observer = new IntersectionObserver((entries) => {
+          for (const entry of entries) {
+            if (entry.isIntersecting) {
+              observer.disconnect();
+              cb();
+              return;
+            }
+          }
+        });
+        observer.observe(el);
+      });
+    };
+  });
+}
+function appearsTrigger(QSL) {
+  QSL.triggerHandlers.add(function(opt) {
+    if (!isPrefixed(opt, "appears:")) return null;
+    const selector = arg(opt, "appears:");
+    return (cb) => whenElement(selector, () => cb());
+  });
+}
+function mediaQueryTrigger(QSL) {
+  QSL.triggerHandlers.add(function(opt, o) {
+    if (!isPrefixed(opt, "media:")) return null;
+    const query = arg(opt, "media:");
+    return (cb) => {
+      if (!query.length || typeof window.matchMedia !== "function") {
+        if (o) o.skipped = true;
+        cb();
+        return;
+      }
+      const mql = window.matchMedia(query);
+      if (mql.matches) {
+        cb();
+        return;
+      }
+      const handler = (e) => {
+        if (!e.matches) return;
+        mql.removeEventListener("change", handler);
+        cb();
+      };
+      mql.addEventListener("change", handler);
+    };
+  });
+}
+function triggers(QSL) {
+  loadTrigger(QSL);
+  idleTrigger(QSL);
+  domReadyTrigger(QSL);
+  delayTrigger(QSL);
+  hoverTrigger(QSL);
+  visibleTrigger(QSL);
+  appearsTrigger(QSL);
+  mediaQueryTrigger(QSL);
+}
+function logger(QSL) {
+  QSL.initActions.add(function() {
+    QSL.logger = {
+      VERSION: "qsl-logger",
+      LOG: {
+        LOGGER_LOADED: "[QSL] Logger loaded",
+        LOGGER_LOAD_ERROR: "[QSL] Logger load error:",
+        UNKNOWN_TYPE: "[QSL] Unknown type:",
+        PROCESS_STARTED: "[QSL] Process started:",
+        PROCESS_COMPLETED: "[QSL] Process completed:",
+        PROCESS_FAILED: "[QSL] Process failed:",
+        STYLESHEET_STARTED: "[QSL] Stylesheet loading:",
+        STYLESHEET_LOADED: "[QSL] Stylesheet loaded:",
+        STYLESHEET_FAILED: "[QSL] Stylesheet failed to load:",
+        INLINE_SCRIPT_STARTED: "[QSL] Inline script loading:",
+        INLINE_SCRIPT_SUCCESS: "[QSL] Inline script loaded:",
+        INLINE_SCRIPT_ERROR: "[QSL] Inline script load error:",
+        INLINE_STYLE_STARTED: "[QSL] Inline style loading:",
+        INLINE_STYLE_SUCCESS: "[QSL] Inline style loaded:",
+        INLINE_STYLE_ERROR: "[QSL] Inline style load error:",
+        IMAGE_STARTED: "[QSL] Image pixel loading:",
+        IMAGE_LOADED: "[QSL] Image pixel loaded:",
+        IMAGE_FAILED: "[QSL] Image pixel failed:",
+        SHADOW_STARTED: "[QSL] Shadow element loading:",
+        SHADOW_SUCCESS: "[QSL] Shadow element loaded:",
+        SHADOW_FAILED: "[QSL] Shadow element failed:",
+        HTML_STARTED: "[QSL] HTML element loading:",
+        HTML_SUCCESS: "[QSL] HTML element loaded:",
+        HTML_FAILED: "[QSL] HTML element failed:",
+        PRELOAD_ERROR: "[QSL] Preload error:",
+        FLOW_DEP_SKIPPED: "[QSL] Flow dependency missed:",
+        DEP_NOT_FOUND: "[QSL] Dependency not found:",
+        RESET: "[QSL] Global reset",
+        ALL_COMPLETED: "[QSL] Loading is completed"
+      },
+      log(type, ...args) {
+        if (this.LOG[type]) {
+          console.log(this.LOG[type], ...args, { timestamp: Date.now() });
+        } else {
+          console.log("[QSL] " + type, ...args);
+        }
+      },
+      error(type, ...args) {
+        if (this.LOG[type]) {
+          console.error(this.LOG[type], ...args);
+        } else {
+          console.error("[QSL] " + type, ...args);
+        }
+      }
+    };
+  });
+}
+function events(QSL) {
+  const customEvents = /* @__PURE__ */ new Map();
+  const processElementMap = /* @__PURE__ */ new WeakMap();
+  let documentListener = null;
+  let windowListener = null;
+  let isIntercepting = false;
+  const normalizeScriptPath = (u) => {
+    if (!u) return "";
+    try {
+      return u.includes("://") ? new URL(u).pathname : u.split("?")[0].split("#")[0];
+    } catch (e) {
+      return u.split("?")[0].split("#")[0];
+    }
+  };
+  QSL.loadActions.add(function() {
+    if (isIntercepting) return;
+    documentListener = document.addEventListener;
+    windowListener = window.addEventListener;
+    isIntercepting = true;
+    const iterator = (type, eventType, changeEventName) => {
+      var _a;
+      let currentScriptId = null;
+      let targetFlowId = null;
+      if (document.currentScript) {
+        const processElement = processElementMap.get(document.currentScript);
+        if (processElement) {
+          currentScriptId = processElement.processId;
+          targetFlowId = processElement.flowId;
+        }
+      }
+      if (!currentScriptId && this.currentProcessPerFlow.size) {
+        for (const [flowId, processId] of this.currentProcessPerFlow) {
+          if (processId) {
+            currentScriptId = processId;
+            targetFlowId = flowId;
+            break;
+          }
+        }
+      }
+      if (!currentScriptId) {
+        const stack = new Error().stack;
+        if (stack) {
+          const lines = stack.split("\n");
+          for (let i = 2; i < lines.length; i++) {
+            const match = lines[i].match(/([^()\s]+\.js(?:\?[^:)]*)?):\d+(?::\d+)?/);
+            if (match) {
+              const file = match[1];
+              const qIndex = file.indexOf("?");
+              const stackFile = qIndex === -1 ? file.trim() : file.slice(0, qIndex).trim();
+              if (stackFile) {
+                const qIdx = stackFile.indexOf("?");
+                const hIdx = stackFile.indexOf("#");
+                const endIdx = qIdx === -1 ? hIdx === -1 ? stackFile.length : hIdx : hIdx === -1 ? qIdx : Math.min(qIdx, hIdx);
+                let normalizedFile = stackFile.slice(0, endIdx);
+                try {
+                  if (normalizedFile.includes("://")) {
+                    normalizedFile = new URL(normalizedFile).pathname;
+                  }
+                } catch (e) {
+                }
+                const lastSlash = normalizedFile.lastIndexOf("/");
+                const fileName = lastSlash === -1 ? normalizedFile : normalizedFile.slice(lastSlash + 1);
+                for (const [flowId, processes] of this.flows) {
+                  for (const process of processes) {
+                    if (process.src && process.type === "script") {
+                      const normalizedSrc = normalizeScriptPath(process.src);
+                      const srcLastSlash = normalizedSrc.lastIndexOf("/");
+                      const srcFileName = srcLastSlash === -1 ? normalizedSrc : normalizedSrc.slice(srcLastSlash + 1);
+                      if (normalizedFile === normalizedSrc || fileName && fileName === srcFileName) {
+                        currentScriptId = process.id;
+                        targetFlowId = flowId;
+                        break;
+                      }
+                    }
+                  }
+                  if (currentScriptId) break;
+                }
+                if (currentScriptId) break;
+              }
+            }
+          }
+        }
+      }
+      if (currentScriptId && targetFlowId) {
+        const flow = this.flows.get(targetFlowId);
+        const process = flow == null ? void 0 : flow.find((p) => p.id === currentScriptId || p.id === this.PREFIX + currentScriptId);
+        if (process) {
+          const shouldFireEvents = process.fireEvents !== false && ((_a = this.flowOptions.get(targetFlowId)) == null ? void 0 : _a.fireEvents) !== false;
+          if (shouldFireEvents) {
+            const eventName = `${type}:${process.id}`;
+            if (!customEvents.has(process.id)) customEvents.set(process.id, []);
+            const events2 = customEvents.get(process.id);
+            if (!events2.some((e) => e.name === eventName)) events2.push({ type: eventType, name: eventName });
+            if (changeEventName) type = eventName;
+          }
+        }
+      }
+      return type;
+    };
+    document.addEventListener = (type, listener, opts) => {
+      if (type === "DOMContentLoaded" && this.LIFECYCLE.DOMREADY) {
+        const trackedType = iterator.call(this, type, this.EVENTS.DOMREADY, true);
+        if (trackedType !== type) {
+          type = trackedType;
+          queueMicrotask(() => document.dispatchEvent(new Event(trackedType)));
+        }
+      }
+      return documentListener.call(document, type, listener, opts);
+    };
+    window.addEventListener = (type, listener, opts) => {
+      if (type === "load" && this.LIFECYCLE.LOADED) {
+        const trackedType = iterator.call(this, type, this.EVENTS.LOADED, true);
+        if (trackedType !== type) {
+          type = trackedType;
+          queueMicrotask(() => window.dispatchEvent(new Event(trackedType)));
+        }
+      }
+      return windowListener.call(window, type, listener, opts);
+    };
+  });
+  QSL.handlerCallbacksFilters.add(function(process) {
+    return {
+      registerProcessElement: (el, config) => {
+        processElementMap.set(el, { flowId: config.flowId, processId: config.id });
+      }
+    };
+  });
+  QSL.processCompleteActions.add(function(process) {
+    const events2 = customEvents.get(process.id);
+    if (events2 && Array.isArray(events2)) {
+      for (const event of events2) {
+        if (event.type === this.EVENTS.DOMREADY) {
+          if (this.LIFECYCLE.DOMREADY) {
+            document.dispatchEvent(new Event(event.name));
+          } else {
+            document.addEventListener("DOMContentLoaded", () => {
+              document.dispatchEvent(new Event(event.name));
+            }, { once: true });
+          }
+        } else if (event.type === this.EVENTS.LOADED) {
+          if (this.LIFECYCLE.LOADED) {
+            window.dispatchEvent(new Event(event.name));
+          } else {
+            window.addEventListener("load", () => {
+              window.dispatchEvent(new Event(event.name));
+            }, { once: true });
+          }
+        }
+      }
+    }
+  });
+  QSL.resetActions.add(function() {
+    if (isIntercepting && documentListener && windowListener) {
+      document.addEventListener = documentListener;
+      window.addEventListener = windowListener;
+      isIntercepting = false;
+    }
+  });
+  QSL.customEvents = customEvents;
+}
+function circ(QSL) {
+  QSL.loadActions.add(function() {
+    const detectCircularDependency = (id, getDeps, visited = /* @__PURE__ */ new Set()) => {
+      if (visited.has(id)) return true;
+      visited.add(id);
+      const deps = getDeps(id) || [];
+      for (const depId of deps) {
+        if (detectCircularDependency(depId, getDeps, new Set(visited))) return true;
+      }
+      return false;
+    };
+    const getFlowDeps = (id) => {
+      var _a;
+      return ((_a = this.flowOptions.get(this.normalizeFlowId(id))) == null ? void 0 : _a.depends) || [];
+    };
+    for (const [fid, options] of this.flowOptions.entries()) {
+      if (Array.isArray(options.depends) && options.depends.length) {
+        if (detectCircularDependency(fid, getFlowDeps)) {
+          this.log("CIRC_FLOW_DEP_SKIPPED", fid, options.depends);
+          this.setFlowOptions({ status: this.FLOW_STATE.COMPLETED }, fid);
+        }
+      }
+    }
+    const getProcDeps = (id) => {
+      for (const flow of this.flows.values()) {
+        const proc = flow.find((p) => p.id === id);
+        if (proc && Array.isArray(proc.depends)) return proc.depends.map((dep) => this.PREFIX + dep);
+      }
+      return [];
+    };
+    for (const flow of this.flows.values()) {
+      for (const process of flow) {
+        if (Array.isArray(process.depends) && process.depends.length) {
+          if (detectCircularDependency(process.id, getProcDeps)) {
+            this.log("CIRC_PROCESS_DEP_SKIPPED", process.id, process.depends);
+            process.condition = false;
+          }
+        }
+      }
+    }
+  });
+  if (QSL.logger && QSL.logger.VERSION === "qsl-logger") {
+    QSL.logger.LOG.CIRC_FLOW_DEP_SKIPPED = "[QSL] Circular flow dependency skipped:";
+    QSL.logger.LOG.CIRC_PROCESS_DEP_SKIPPED = "[QSL] Circular process dependency skipped:";
+  }
+}
+function dynamic(QSL) {
+  QSL.addProcessFilters.add(function(flowId, config) {
+    if (this.hasStarted && !flowId) {
+      flowId = "dynamic-" + Math.random().toString(36).slice(2);
+      config.paused = true;
+    }
+    return [flowId, config];
+  });
+  QSL.flowIdFilters.add(function(flowIds) {
+    return flowIds.filter((fid) => !fid.includes("dynamic"));
+  });
+  QSL.completedFlowsActions.add(function(flowsDone, flows, flowOptions) {
+    if (!flowsDone || !flows || !flowOptions) return true;
+    const nonDynamicFlowsDone = [...flowOptions.entries()].filter(([fid]) => !fid.includes("dynamic")).every(([, opt]) => opt.status === this.FLOW_STATE.COMPLETED);
+    if (!nonDynamicFlowsDone) return false;
+    const dynamicFlowIds = [...flows.keys()].filter((fid) => fid.includes("dynamic"));
+    if (dynamicFlowIds.length === 0) return true;
+    for (const dynamicFlowId of dynamicFlowIds) {
+      const dynamicOptions = flowOptions.get(dynamicFlowId);
+      if (dynamicOptions && dynamicOptions.status !== this.FLOW_STATE.COMPLETED) {
+        if (dynamicOptions.status === this.FLOW_STATE.READY) {
+          this.setFlowOptions({ status: this.FLOW_STATE.RUNNING }, dynamicFlowId);
+          this.runFlow(dynamicFlowId);
+        }
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function simpleEvents(QSL) {
+  QSL.allCompleteActions.add(function() {
+    document.dispatchEvent(new Event("DOMContentLoaded"));
+    window.dispatchEvent(new Event("load"));
+  });
+}
+export {
+  HTML,
+  InlineScript,
+  InlineStyle,
+  Pixel,
+  Script,
+  Shadow,
+  Stylesheet,
+  appearsTrigger,
+  circ,
+  conditions,
+  core,
+  core as default,
+  delayTrigger,
+  domReadyTrigger,
+  dynamic,
+  events,
+  hoverTrigger,
+  idleTrigger,
+  languageCondition,
+  loadTrigger,
+  logger,
+  mediaQueryCondition,
+  mediaQueryTrigger,
+  simpleEvents,
+  timezoneCondition,
+  triggers,
+  urlCondition,
+  userAgentCondition,
+  visibleTrigger
+};
+//# sourceMappingURL=qsl.mjs.map