@framesquared/core 0.1.0

package/dist/index.js

@@ -0,0 +1,3108 @@
+// src/util/index.ts
+function identity(value) {
+  return value;
+}
+function emptyFn() {
+}
+function applyIf(target, source) {
+  const keys2 = Object.keys(source);
+  for (const key of keys2) {
+    if (!(key in target)) {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function apply(target, ...sources) {
+  for (const source of sources) {
+    const keys2 = Object.keys(source);
+    for (const key of keys2) {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function clone(value) {
+  return structuredClone(value);
+}
+function isObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number" && !Number.isNaN(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isDefined(value) {
+  return value !== void 0 && value !== null;
+}
+function isEmpty(value) {
+  if (value === void 0 || value === null) return true;
+  if (typeof value === "number") return Number.isNaN(value);
+  if (typeof value === "string") return value.length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (isObject(value)) return Object.keys(value).length === 0;
+  return false;
+}
+function isIterable(value) {
+  if (value === null || value === void 0) return false;
+  return typeof value[Symbol.iterator] === "function";
+}
+function isPrimitive(value) {
+  if (value === null) return true;
+  const t = typeof value;
+  return t !== "object" && t !== "function";
+}
+function namespace(root, path) {
+  const segments = path.split(".");
+  let current = root;
+  for (const segment of segments) {
+    if (current[segment] === void 0 || current[segment] === null) {
+      current[segment] = {};
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function defer(fn, millis = 0) {
+  return +setTimeout(fn, millis);
+}
+function interval(fn, millis) {
+  return +setInterval(fn, millis);
+}
+function now() {
+  return performance.now();
+}
+var idCounter = 0;
+function generateId(prefix = "framesquared") {
+  return `${prefix}-${++idCounter}`;
+}
+
+// src/util/String.ts
+function capitalize(str) {
+  if (str.length === 0) return str;
+  return str[0].toUpperCase() + str.slice(1);
+}
+function uncapitalize(str) {
+  if (str.length === 0) return str;
+  return str[0].toLowerCase() + str.slice(1);
+}
+function ellipsis(value, length, word) {
+  if (value.length <= length) return value;
+  if (length <= 3) return "...";
+  const truncLen = length - 3;
+  if (word) {
+    const lastSpace = value.lastIndexOf(" ", truncLen);
+    if (lastSpace > 0) {
+      return value.slice(0, lastSpace) + "...";
+    }
+  }
+  return value.slice(0, truncLen) + "...";
+}
+var HTML_ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var HTML_UNESCAPE_MAP = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'"
+};
+var HTML_ESCAPE_RE = /[&<>"']/g;
+var HTML_UNESCAPE_RE = /&amp;|&lt;|&gt;|&quot;|&#39;/g;
+function escapeHtml(str) {
+  return str.replace(HTML_ESCAPE_RE, (ch) => HTML_ESCAPE_MAP[ch]);
+}
+function unescapeHtml(str) {
+  return str.replace(HTML_UNESCAPE_RE, (entity) => HTML_UNESCAPE_MAP[entity]);
+}
+var htmlEncode = escapeHtml;
+var htmlDecode = unescapeHtml;
+var REGEX_SPECIAL_RE = /[.*+?^${}()|[\]\\]/g;
+function escapeRegex(str) {
+  return str.replace(REGEX_SPECIAL_RE, "\\$&");
+}
+function format(template, ...values2) {
+  return template.replace(/\{(\d+)}/g, (match, index) => {
+    const i = Number(index);
+    return i < values2.length ? String(values2[i]) : match;
+  });
+}
+function repeat(str, count) {
+  return str.repeat(count);
+}
+function trim(str) {
+  return str.trim();
+}
+function leftPad(str, size, char = " ") {
+  const padChar = char[0];
+  const needed = size - str.length;
+  if (needed <= 0) return str;
+  return padChar.repeat(needed) + str;
+}
+function toggle(str, value1, value2) {
+  return str === value1 ? value2 : value1;
+}
+function splitWords(str) {
+  if (str.length === 0) return [];
+  const withBoundaries = str.replace(/([a-z0-9])([A-Z])/g, "$1\0$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1\0$2");
+  return withBoundaries.split(/[\0_-]+/).filter(Boolean);
+}
+function camelCase(str) {
+  const words = splitWords(str);
+  if (words.length === 0) return "";
+  return words.map((w, i) => {
+    const lower = w.toLowerCase();
+    return i === 0 ? lower : capitalize(lower);
+  }).join("");
+}
+function kebabCase(str) {
+  const words = splitWords(str);
+  return words.map((w) => w.toLowerCase()).join("-");
+}
+function pascalCase(str) {
+  const words = splitWords(str);
+  return words.map((w) => capitalize(w.toLowerCase())).join("");
+}
+
+// src/util/Array.ts
+function from(value) {
+  if (Array.isArray(value)) return value;
+  if (typeof value !== "string" && value != null && typeof value[Symbol.iterator] === "function") {
+    return [...value];
+  }
+  return [value];
+}
+function contains(array, item) {
+  return array.includes(item);
+}
+function include(array, item) {
+  if (!array.includes(item)) {
+    array.push(item);
+  }
+  return array;
+}
+function remove(array, item) {
+  const idx = array.indexOf(item);
+  if (idx !== -1) {
+    array.splice(idx, 1);
+  }
+  return array;
+}
+function clean(array) {
+  return array.filter((v) => v !== null && v !== void 0);
+}
+function unique(array) {
+  return [...new Set(array)];
+}
+function flatten(array) {
+  const result = [];
+  for (const item of array) {
+    if (Array.isArray(item)) {
+      result.push(...item);
+    } else {
+      result.push(item);
+    }
+  }
+  return result;
+}
+function pluck(array, key) {
+  return array.map((item) => item[key]);
+}
+function sum(array) {
+  let total = 0;
+  for (const n of array) total += n;
+  return total;
+}
+function mean(array) {
+  if (array.length === 0) return NaN;
+  return sum(array) / array.length;
+}
+function min(array, compareFn) {
+  if (array.length === 0) throw new Error("min() requires a non-empty array");
+  const cmp = compareFn ?? defaultCompare;
+  let result = array[0];
+  for (let i = 1; i < array.length; i++) {
+    if (cmp(array[i], result) < 0) result = array[i];
+  }
+  return result;
+}
+function max(array, compareFn) {
+  if (array.length === 0) throw new Error("max() requires a non-empty array");
+  const cmp = compareFn ?? defaultCompare;
+  let result = array[0];
+  for (let i = 1; i < array.length; i++) {
+    if (cmp(array[i], result) > 0) result = array[i];
+  }
+  return result;
+}
+function defaultCompare(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+function groupBy(array, fn) {
+  const result = {};
+  for (const item of array) {
+    const key = fn(item);
+    if (result[key] === void 0) {
+      result[key] = [];
+    }
+    result[key].push(item);
+  }
+  return result;
+}
+function partition(array, predicate) {
+  const yes = [];
+  const no = [];
+  for (const item of array) {
+    (predicate(item) ? yes : no).push(item);
+  }
+  return [yes, no];
+}
+function chunk(array, size) {
+  if (size <= 0) throw new Error("chunk() requires a positive size");
+  const result = [];
+  for (let i = 0; i < array.length; i += size) {
+    result.push(array.slice(i, i + size));
+  }
+  return result;
+}
+function difference(array1, array2) {
+  const set = new Set(array2);
+  return array1.filter((item) => !set.has(item));
+}
+function intersection(array1, array2) {
+  const set = new Set(array2);
+  return unique(array1.filter((item) => set.has(item)));
+}
+function sortBy(array, key, direction = "ASC") {
+  const accessor = typeof key === "function" ? key : (item) => item[key];
+  const dir = direction === "DESC" ? -1 : 1;
+  return [...array].sort((a, b) => {
+    const va = accessor(a);
+    const vb = accessor(b);
+    if (va < vb) return -1 * dir;
+    if (va > vb) return 1 * dir;
+    return 0;
+  });
+}
+function findBy(array, fn) {
+  return array.find(fn);
+}
+function range(start, end, step = 1) {
+  if (step === 0) throw new Error("range() step must not be zero");
+  const result = [];
+  if (step > 0) {
+    for (let i = start; i < end; i += step) result.push(i);
+  } else {
+    for (let i = start; i > end; i += step) result.push(i);
+  }
+  return result;
+}
+
+// src/util/Object.ts
+function keys(obj) {
+  return Object.keys(obj);
+}
+function values(obj) {
+  return Object.values(obj);
+}
+function entries(obj) {
+  return Object.entries(obj);
+}
+function fromEntries(items) {
+  return Object.fromEntries(items);
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function merge(target, ...sources) {
+  for (const source of sources) {
+    for (const key of Object.keys(source)) {
+      const srcVal = source[key];
+      const tgtVal = target[key];
+      if (isPlainObject(srcVal) && isPlainObject(tgtVal)) {
+        merge(tgtVal, srcVal);
+      } else {
+        target[key] = srcVal;
+      }
+    }
+  }
+  return target;
+}
+function pick(obj, pickedKeys) {
+  const result = {};
+  for (const key of pickedKeys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function omit(obj, omittedKeys) {
+  const excluded = new Set(omittedKeys);
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    if (!excluded.has(key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function mapValues(obj, fn) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    result[key] = fn(obj[key], key);
+  }
+  return result;
+}
+function mapKeys(obj, fn) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    result[fn(key)] = obj[key];
+  }
+  return result;
+}
+function freeze(obj) {
+  Object.freeze(obj);
+  for (const value of Object.values(obj)) {
+    if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+      freeze(value);
+    }
+  }
+  return obj;
+}
+function equals(a, b) {
+  if (a === b) return true;
+  if (typeof a === "number" && typeof b === "number") {
+    return Number.isNaN(a) && Number.isNaN(b);
+  }
+  if (a === null || b === null || a === void 0 || b === void 0) {
+    return false;
+  }
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  const aIsArr = Array.isArray(a);
+  const bIsArr = Array.isArray(b);
+  if (aIsArr !== bIsArr) return false;
+  if (aIsArr && bIsArr) {
+    const arrA = a;
+    const arrB = b;
+    if (arrA.length !== arrB.length) return false;
+    for (let i = 0; i < arrA.length; i++) {
+      if (!equals(arrA[i], arrB[i])) return false;
+    }
+    return true;
+  }
+  const objA = a;
+  const objB = b;
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(objB, key)) return false;
+    if (!equals(objA[key], objB[key])) return false;
+  }
+  return true;
+}
+function getNestedValue(obj, path, defaultValue) {
+  const segments = path.split(".");
+  let current = obj;
+  for (let i = 0; i < segments.length; i++) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return defaultValue;
+    }
+    const rec = current;
+    const seg = segments[i];
+    if (i === segments.length - 1) {
+      return seg in rec ? rec[seg] : defaultValue;
+    }
+    current = rec[seg];
+  }
+  return current;
+}
+function setNestedValue(obj, path, value) {
+  const segments = path.split(".");
+  let current = obj;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    if (current[seg] === void 0 || current[seg] === null || typeof current[seg] !== "object") {
+      current[seg] = {};
+    }
+    current = current[seg];
+  }
+  current[segments[segments.length - 1]] = value;
+}
+function flattenObject(obj, prefix) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (isPlainObject(value)) {
+      Object.assign(result, flattenObject(value, fullKey));
+    } else {
+      result[fullKey] = value;
+    }
+  }
+  return result;
+}
+function unflattenObject(obj) {
+  const result = {};
+  for (const [path, value] of Object.entries(obj)) {
+    setNestedValue(result, path, value);
+  }
+  return result;
+}
+
+// src/util/Function.ts
+function bind(fn, scope, ...args) {
+  return ((...callArgs) => fn.apply(scope, [...args, ...callArgs]));
+}
+function createBuffered(fn, buffer, scope) {
+  let timerId;
+  return function(...args) {
+    if (timerId !== void 0) clearTimeout(timerId);
+    const ctx = scope ?? this;
+    timerId = setTimeout(() => {
+      fn.apply(ctx, args);
+      timerId = void 0;
+    }, buffer);
+  };
+}
+function createDelayed(fn, delay, scope) {
+  return function(...args) {
+    const ctx = scope ?? this;
+    setTimeout(() => fn.apply(ctx, args), delay);
+  };
+}
+function createThrottled(fn, intervalMs, scope) {
+  let lastCall = 0;
+  return function(...args) {
+    const ctx = scope ?? this;
+    const elapsed = Date.now() - lastCall;
+    if (elapsed >= intervalMs) {
+      lastCall = Date.now();
+      fn.apply(ctx, args);
+    }
+  };
+}
+function createBarrier(count, fn, scope) {
+  let remaining = count;
+  let fired = false;
+  return function(...args) {
+    if (fired) return;
+    remaining--;
+    if (remaining <= 0) {
+      fired = true;
+      const ctx = scope ?? this;
+      fn.apply(ctx, args);
+    }
+  };
+}
+function interceptBefore(obj, methodName, fn) {
+  const rec = obj;
+  const original = rec[methodName];
+  rec[methodName] = function(...args) {
+    fn.apply(this, args);
+    return original.apply(this, args);
+  };
+}
+function interceptAfter(obj, methodName, fn) {
+  const rec = obj;
+  const original = rec[methodName];
+  rec[methodName] = function(...args) {
+    const result = original.apply(this, args);
+    fn.call(this, result);
+    return result;
+  };
+}
+function createSequence(...fns) {
+  return (...args) => {
+    for (const fn of fns) {
+      fn(...args);
+    }
+  };
+}
+function memoize(fn, hasher) {
+  const cache = /* @__PURE__ */ new Map();
+  return ((...args) => {
+    const key = hasher ? hasher(...args) : String(args[0]);
+    if (cache.has(key)) return cache.get(key);
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  });
+}
+function once(fn) {
+  let called = false;
+  let result;
+  return ((...args) => {
+    if (!called) {
+      called = true;
+      result = fn(...args);
+    }
+    return result;
+  });
+}
+function negate(fn) {
+  return ((...args) => !fn(...args));
+}
+function compose(...fns) {
+  return (...args) => {
+    let result = fns[fns.length - 1](...args);
+    for (let i = fns.length - 2; i >= 0; i--) {
+      result = fns[i](result);
+    }
+    return result;
+  };
+}
+function pipe(...fns) {
+  return (...args) => {
+    let result = fns[0](...args);
+    for (let i = 1; i < fns.length; i++) {
+      result = fns[i](result);
+    }
+    return result;
+  };
+}
+
+// src/class/Base.ts
+var CONFIGS_PROCESSED = /* @__PURE__ */ Symbol("configsProcessed");
+function processClassConfigs(Ctor) {
+  if (Object.hasOwn(Ctor, CONFIGS_PROCESSED)) return;
+  const chain = [];
+  let cur = Ctor;
+  while (cur && cur !== Function.prototype) {
+    chain.unshift(cur);
+    cur = Object.getPrototypeOf(cur);
+  }
+  const merged = {};
+  for (const cls of chain) {
+    if (cls.hasOwnProperty("$configDefs")) {
+      Object.assign(merged, cls.$configDefs);
+    }
+  }
+  Ctor.$configDefs = merged;
+  for (const configName of Object.keys(merged)) {
+    generateAccessors(Ctor.prototype, configName);
+  }
+  Ctor[CONFIGS_PROCESSED] = true;
+}
+function generateAccessors(proto, configName) {
+  const cap = capitalize(configName);
+  const getterName = `get${cap}`;
+  const setterName = `set${cap}`;
+  const privateProp = `_${configName}`;
+  const applyName = `apply${cap}`;
+  const updateName = `update${cap}`;
+  if (!(getterName in proto)) {
+    proto[getterName] = function() {
+      if (!this.$configInitialized.has(configName)) {
+        const defaults = this.constructor.$configDefs;
+        if (defaults && configName in defaults) {
+          this[setterName](defaults[configName]);
+        }
+      }
+      return this[privateProp];
+    };
+  }
+  if (!(setterName in proto)) {
+    proto[setterName] = function(value) {
+      const oldValue = this[privateProp];
+      if (typeof this[applyName] === "function") {
+        value = this[applyName](value, oldValue);
+      }
+      this[privateProp] = value;
+      this.$configInitialized.add(configName);
+      if (typeof this[updateName] === "function" && value !== oldValue) {
+        this[updateName](value, oldValue);
+      }
+    };
+  }
+}
+function wrapMethod(fn, methodName, ownerClass) {
+  const wrapped = function(...args) {
+    this.$callStack.push({ methodName, owner: ownerClass });
+    try {
+      return fn.apply(this, args);
+    } finally {
+      this.$callStack.pop();
+    }
+  };
+  wrapped.$wrapped = true;
+  wrapped.$original = fn;
+  wrapped.$owner = ownerClass;
+  return wrapped;
+}
+var Base = class {
+  // -- Class-level metadata ------------------------------------------------
+  /** Fully-qualified class name. */
+  static $className = "Base";
+  /** Merged config defaults for this class (populated by processClassConfigs). */
+  static $configDefs;
+  /** Set of mixin constructors applied to this class (populated by define). */
+  static $mixins;
+  // -- Instance state ------------------------------------------------------
+  /** Per-instance call-stack used by `callParent()`. */
+  $callStack = [];
+  /** Tracks which config properties have been explicitly initialized. */
+  $configInitialized = /* @__PURE__ */ new Set();
+  /**
+   * Raw config object passed to the constructor.  Decorator-based configs
+   * are consumed from here by `addInitializer` callbacks (which run after
+   * auto-accessor field initialization).
+   */
+  $pendingConfig;
+  /** Whether `destroy()` has been called. */
+  isDestroyed = false;
+  /**
+   * Array of cleanup callbacks.  Mixins (and user code) can push
+   * functions here; they all run during `destroy()`.
+   */
+  $destroyHooks = [];
+  // -- Getters -------------------------------------------------------------
+  /** The fully-qualified class name of this instance's constructor. */
+  get $className() {
+    return this.constructor.$className;
+  }
+  /** Reference to the constructor (like ExtJS's `this.self`). */
+  get self() {
+    return this.constructor;
+  }
+  // -- Constructor ---------------------------------------------------------
+  constructor(config2) {
+    this.$pendingConfig = config2 ? { ...config2 } : void 0;
+    if (config2) {
+      this.initConfig(config2);
+    }
+  }
+  // -- Factory -------------------------------------------------------------
+  /**
+   * Static factory — creates an instance of the class.
+   */
+  static create(...args) {
+    return new this(...args);
+  }
+  // -- Config initialisation -----------------------------------------------
+  /**
+   * Applies the given config properties to this instance.  Ensures that
+   * config accessors have been generated for the class first.
+   */
+  initConfig(config2) {
+    const Ctor = this.constructor;
+    processClassConfigs(Ctor);
+    if (!config2) return;
+    const defs = Ctor.$configDefs;
+    for (const key of Object.keys(config2)) {
+      if (defs && key in defs) {
+        const setter = `set${capitalize(key)}`;
+        if (typeof this[setter] === "function") {
+          this[setter](config2[key]);
+        }
+      }
+    }
+  }
+  // -- callParent ----------------------------------------------------------
+  /**
+   * Calls the parent (super) class's implementation of the method that is
+   * currently executing.  Only works for methods wrapped via `define()`.
+   */
+  callParent(args) {
+    const stack = this.$callStack;
+    if (stack.length === 0) {
+      return void 0;
+    }
+    const current = stack[stack.length - 1];
+    const parentProto = Object.getPrototypeOf(current.owner.prototype);
+    if (parentProto && typeof parentProto[current.methodName] === "function") {
+      return parentProto[current.methodName].apply(this, args ?? []);
+    }
+    return void 0;
+  }
+  // -- Mixin query ---------------------------------------------------------
+  /**
+   * Returns `true` if the given mixin has been applied to this class (or
+   * to any of its ancestors / other mixins).
+   */
+  hasMixin(mixin2) {
+    const Ctor = this.constructor;
+    return Ctor.$mixins?.has(mixin2) ?? false;
+  }
+  // -- Destroy lifecycle ---------------------------------------------------
+  /**
+   * Tears down this instance.  Calls `onDestroy()` if defined.
+   * Idempotent — second and subsequent calls are no-ops.
+   */
+  destroy() {
+    if (this.isDestroyed) return;
+    this.isDestroyed = true;
+    for (const hook of this.$destroyHooks) {
+      hook.call(this);
+    }
+    if (typeof this.onDestroy === "function") {
+      this.onDestroy();
+    }
+  }
+  /**
+   * `Symbol.dispose` support — calling `[Symbol.dispose]()` is equivalent
+   * to `destroy()`, enabling the TC39 `using` keyword.
+   */
+  [Symbol.dispose]() {
+    this.destroy();
+  }
+};
+
+// src/class/ClassManager.ts
+var RESERVED_DEF_KEYS = /* @__PURE__ */ new Set([
+  "extend",
+  "mixins",
+  "alias",
+  "config",
+  "statics"
+]);
+var ClassManagerImpl = class {
+  /** className → constructor */
+  classes = /* @__PURE__ */ new Map();
+  /** alias → constructor */
+  aliases = /* @__PURE__ */ new Map();
+  // -- Registration -------------------------------------------------------
+  register(name, cls) {
+    this.classes.set(name, cls);
+  }
+  // -- Lookup -------------------------------------------------------------
+  get(name) {
+    return this.classes.get(name);
+  }
+  getByAlias(alias2) {
+    return this.aliases.get(alias2);
+  }
+  isRegistered(name) {
+    return this.classes.has(name);
+  }
+  /**
+   * Returns all registered class names that start with `prefix`.
+   */
+  getNamesByPrefix(prefix) {
+    const result = [];
+    for (const name of this.classes.keys()) {
+      if (name.startsWith(prefix)) result.push(name);
+    }
+    return result;
+  }
+  // -- Instantiation ------------------------------------------------------
+  /**
+   * Creates an instance by alias, passing remaining args to the constructor.
+   */
+  instantiateByAlias(alias2, ...args) {
+    const Cls = this.aliases.get(alias2);
+    if (!Cls) {
+      throw new Error(`ClassManager: no class registered for alias "${alias2}"`);
+    }
+    return new Cls(...args);
+  }
+  // -- Alias management (used by define) ----------------------------------
+  registerAlias(alias2, cls) {
+    this.aliases.set(alias2, cls);
+  }
+};
+var ClassManager = new ClassManagerImpl();
+function applyMixins(targetClass, mixins) {
+  if (!targetClass.$mixins) {
+    targetClass.$mixins = /* @__PURE__ */ new Set();
+  }
+  for (const mixin2 of mixins) {
+    if (targetClass.$mixins.has(mixin2)) continue;
+    targetClass.$mixins.add(mixin2);
+    if (mixin2.$mixins) {
+      for (const transitive of mixin2.$mixins) {
+        targetClass.$mixins.add(transitive);
+      }
+    }
+    for (const name of Object.getOwnPropertyNames(mixin2.prototype)) {
+      if (name === "constructor") continue;
+      if (name in targetClass.prototype) continue;
+      const desc = Object.getOwnPropertyDescriptor(mixin2.prototype, name);
+      if (desc) {
+        Object.defineProperty(targetClass.prototype, name, desc);
+      }
+    }
+    if (mixin2.$configDefs) {
+      targetClass.$configDefs = {
+        ...mixin2.$configDefs,
+        ...targetClass.$configDefs || {}
+      };
+    }
+  }
+}
+function define(className, definition) {
+  const SuperClass = definition.extend || Base;
+  const NewClass = class extends SuperClass {
+    constructor(...args) {
+      super(...args);
+    }
+  };
+  NewClass.$className = className;
+  if (definition.config) {
+    NewClass.$configDefs = {
+      ...SuperClass.$configDefs || {},
+      ...definition.config
+    };
+  } else {
+    if (SuperClass.$configDefs) {
+      NewClass.$configDefs = { ...SuperClass.$configDefs };
+    }
+  }
+  for (const key of Object.keys(definition)) {
+    if (RESERVED_DEF_KEYS.has(key)) continue;
+    const value = definition[key];
+    if (typeof value === "function") {
+      NewClass.prototype[key] = wrapMethod(value, key, NewClass);
+    } else {
+      NewClass.prototype[key] = value;
+    }
+  }
+  if (definition.mixins && definition.mixins.length > 0) {
+    applyMixins(NewClass, definition.mixins);
+  }
+  if (!NewClass.$mixins) {
+    NewClass.$mixins = /* @__PURE__ */ new Set();
+  }
+  processClassConfigs(NewClass);
+  if (definition.statics) {
+    for (const [k, v] of Object.entries(definition.statics)) {
+      NewClass[k] = v;
+    }
+  }
+  ClassManager.register(className, NewClass);
+  if (definition.alias) {
+    const aliases = Array.isArray(definition.alias) ? definition.alias : [definition.alias];
+    for (const a of aliases) {
+      ClassManager.registerAlias(a, NewClass);
+    }
+  }
+  return NewClass;
+}
+
+// src/class/Configurator.ts
+var CONFIG_META_KEY = /* @__PURE__ */ Symbol("framesquared:configMeta");
+var METADATA_SYMBOL = Symbol.metadata ?? /* @__PURE__ */ Symbol.for("Symbol.metadata");
+function getOrCreateMetaMap(metadata) {
+  let map = metadata[CONFIG_META_KEY];
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    metadata[CONFIG_META_KEY] = map;
+  }
+  return map;
+}
+function getClassMetadata(Ctor) {
+  return Ctor[METADATA_SYMBOL];
+}
+var ConfiguratorImpl = class {
+  /**
+   * Returns the ConfigMeta for a single config on the given class,
+   * walking the prototype chain.
+   */
+  getConfigMeta(Ctor, configName) {
+    let cur = Ctor;
+    while (cur) {
+      const md = getClassMetadata(cur);
+      if (md) {
+        const map = md[CONFIG_META_KEY];
+        if (map?.has(configName)) return map.get(configName);
+      }
+      cur = Object.getPrototypeOf(cur);
+    }
+    return void 0;
+  }
+  /**
+   * Collects all ConfigMeta entries for `Ctor`, including inherited.
+   */
+  getAllConfigMeta(Ctor) {
+    const chain = [];
+    let cur = Ctor;
+    while (cur) {
+      chain.unshift(cur);
+      cur = Object.getPrototypeOf(cur);
+    }
+    const merged = /* @__PURE__ */ new Map();
+    for (const cls of chain) {
+      const md = getClassMetadata(cls);
+      if (md) {
+        const map = md[CONFIG_META_KEY];
+        if (map) {
+          for (const [name, meta] of map) merged.set(name, meta);
+        }
+      }
+    }
+    return [...merged.values()];
+  }
+};
+var Configurator = new ConfiguratorImpl();
+
+// src/class/decorators.ts
+function isPlainObject2(v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+var cachedValues = /* @__PURE__ */ new WeakMap();
+function getCacheEntry(inst) {
+  let m = cachedValues.get(inst);
+  if (!m) {
+    m = /* @__PURE__ */ new Map();
+    cachedValues.set(inst, m);
+  }
+  return m;
+}
+function ensureAccessors(Ctor, configName) {
+  const proto = Ctor.prototype;
+  const cap = capitalize(configName);
+  const getter = `get${cap}`;
+  const setter = `set${cap}`;
+  if (!(getter in proto)) {
+    proto[getter] = function() {
+      return this[configName];
+    };
+  }
+  if (!(setter in proto)) {
+    proto[setter] = function(value) {
+      this[configName] = value;
+    };
+  }
+}
+function createConfigDecorator(metaOverrides = {}) {
+  return function(target, context) {
+    const name = String(context.name);
+    const cap = capitalize(name);
+    const applyName = `apply${cap}`;
+    const updateName = `update${cap}`;
+    const metaMap = getOrCreateMetaMap(
+      context.metadata
+    );
+    let meta = metaMap.get(name);
+    if (!meta) {
+      meta = {
+        name,
+        required: false,
+        cached: false,
+        merge: false,
+        observable: false
+      };
+      metaMap.set(name, meta);
+    }
+    Object.assign(meta, metaOverrides);
+    context.addInitializer(function() {
+      const inst = this;
+      const Ctor = inst.constructor;
+      ensureAccessors(Ctor, name);
+      if (inst.$pendingConfig && name in inst.$pendingConfig) {
+        inst[name] = inst.$pendingConfig[name];
+        delete inst.$pendingConfig[name];
+        inst.$configInitialized?.add(name);
+      }
+      if (meta.required && !inst.$configInitialized?.has(name)) {
+        throw new Error(
+          `Config "${name}" is required for ${Ctor.$className || Ctor.name}`
+        );
+      }
+    });
+    const initFn = function(initialValue) {
+      if (this.$configInitialized?.has(name)) {
+        return target.get.call(this);
+      }
+      return initialValue;
+    };
+    const getFn = function() {
+      const inst = this;
+      if (meta.lazyFactory && !inst.$configInitialized?.has(name)) {
+        const computed = meta.lazyFactory.call(inst);
+        target.set.call(this, computed);
+        inst.$configInitialized?.add(name);
+        return computed;
+      }
+      if (meta.cached) {
+        const cacheMap = getCacheEntry(inst);
+        const entry = cacheMap.get(name);
+        if (entry?.valid) {
+          return entry.value;
+        }
+        const value = target.get.call(this);
+        cacheMap.set(name, { valid: true, value });
+        return value;
+      }
+      return target.get.call(this);
+    };
+    const setFn = function(value) {
+      const inst = this;
+      const oldValue = target.get.call(this);
+      if (meta.merge && isPlainObject2(value) && isPlainObject2(oldValue)) {
+        value = merge(
+          {},
+          oldValue,
+          value
+        );
+      }
+      if (typeof inst[applyName] === "function") {
+        value = inst[applyName](value, oldValue);
+      }
+      target.set.call(this, value);
+      if (meta.cached) {
+        const cacheMap = getCacheEntry(inst);
+        cacheMap.set(name, { valid: false, value: void 0 });
+      }
+      inst.$configInitialized?.add(name);
+      if (typeof inst[updateName] === "function" && value !== oldValue) {
+        inst[updateName](value, oldValue);
+      }
+    };
+    return { init: initFn, get: getFn, set: setFn };
+  };
+}
+var config = Object.assign(
+  createConfigDecorator(),
+  {
+    required: createConfigDecorator({ required: true }),
+    lazy(factory) {
+      return createConfigDecorator({ lazyFactory: factory });
+    },
+    cached: createConfigDecorator({ cached: true }),
+    merge: createConfigDecorator({ merge: true })
+  }
+);
+function observable(_target, context) {
+  const name = String(context.name);
+  const metaMap = getOrCreateMetaMap(
+    context.metadata
+  );
+  let meta = metaMap.get(name);
+  if (!meta) {
+    meta = {
+      name,
+      required: false,
+      cached: false,
+      merge: false,
+      observable: true
+    };
+    metaMap.set(name, meta);
+  } else {
+    meta.observable = true;
+  }
+}
+function alias(aliasName) {
+  return function(target, _context) {
+    ClassManager.registerAlias(aliasName, target);
+    return target;
+  };
+}
+function mixin(mixinClass) {
+  return function(target, _context) {
+    const targetCls = target;
+    if (!targetCls.$mixins) targetCls.$mixins = /* @__PURE__ */ new Set();
+    if (targetCls.$mixins.has(mixinClass)) return target;
+    targetCls.$mixins.add(mixinClass);
+    if (mixinClass.$mixins) {
+      for (const m of mixinClass.$mixins) targetCls.$mixins.add(m);
+    }
+    for (const name of Object.getOwnPropertyNames(mixinClass.prototype)) {
+      if (name === "constructor") continue;
+      if (name in targetCls.prototype) continue;
+      const desc = Object.getOwnPropertyDescriptor(mixinClass.prototype, name);
+      if (desc) Object.defineProperty(targetCls.prototype, name, desc);
+    }
+    return target;
+  };
+}
+function override(targetClass) {
+  return function(patchClass, _context) {
+    const patchProto = patchClass.prototype;
+    for (const name of Object.getOwnPropertyNames(patchProto)) {
+      if (name === "constructor") continue;
+      const desc = Object.getOwnPropertyDescriptor(patchProto, name);
+      if (desc) Object.defineProperty(targetClass.prototype, name, desc);
+    }
+    return patchClass;
+  };
+}
+
+// src/mixin/Identifiable.ts
+var IdentityMapImpl = class {
+  map = /* @__PURE__ */ new Map();
+  register(id, instance) {
+    this.map.set(id, instance);
+  }
+  unregister(id) {
+    this.map.delete(id);
+  }
+  get(id) {
+    return this.map.get(id);
+  }
+  has(id) {
+    return this.map.has(id);
+  }
+};
+var IdentityMap = new IdentityMapImpl();
+var Identifiable = define("Ext.mixin.Identifiable", {
+  config: {
+    id: ""
+  },
+  /**
+   * applyId: auto-generates an id if none provided, and registers
+   * in the global identity map.
+   */
+  applyId(id, oldId) {
+    if (oldId) {
+      IdentityMap.unregister(oldId);
+    }
+    if (!id) {
+      id = generateId("framesquared");
+    }
+    IdentityMap.register(id, this);
+    if (!this.$identifiableHooked) {
+      this.$identifiableHooked = true;
+      this.$destroyHooks.push(() => {
+        const currentId = this.getId?.();
+        if (currentId) {
+          IdentityMap.unregister(currentId);
+        }
+      });
+    }
+    return id;
+  }
+});
+
+// src/mixin/Factoryable.ts
+var Factoryable = {
+  /**
+   * Creates a `Base` instance from a config descriptor.
+   *
+   * @param config  An object with `xtype`/`type`, a string alias, or
+   *                an existing `Base` instance.
+   */
+  create(config2) {
+    if (config2 instanceof Base) {
+      return config2;
+    }
+    if (typeof config2 === "string") {
+      return ClassManager.instantiateByAlias(config2);
+    }
+    const alias2 = config2.xtype ?? config2.type;
+    if (!alias2 || typeof alias2 !== "string") {
+      throw new Error(
+        'Factoryable.create(): config must have an "xtype" or "type" property, be a string alias, or be a Base instance'
+      );
+    }
+    const { xtype: _x, type: _t, ...rest } = config2;
+    return ClassManager.instantiateByAlias(alias2, rest);
+  }
+};
+
+// src/mixin/Inheritable.ts
+var ownState = /* @__PURE__ */ new WeakMap();
+var parentRef = /* @__PURE__ */ new WeakMap();
+var Inheritable = define("Ext.mixin.Inheritable", {
+  /**
+   * Sets the parent in the inherited-state chain.
+   */
+  setInheritedParent(parent) {
+    parentRef.set(this, parent);
+  },
+  /**
+   * Returns the parent in the inherited-state chain, or undefined.
+   */
+  getInheritedParent() {
+    return parentRef.get(this);
+  },
+  /**
+   * Stores this instance's own inherited state.  This is typically
+   * called during component setup.
+   */
+  initInheritedState(state) {
+    ownState.set(this, state);
+  },
+  /**
+   * Returns the fully merged inherited state, walking up the parent chain.
+   * Own state overrides parent state on key collisions.
+   */
+  getInherited() {
+    const parent = parentRef.get(this);
+    const parentState = parent && typeof parent.getInherited === "function" ? parent.getInherited() : {};
+    const own = ownState.get(this) ?? {};
+    return { ...parentState, ...own };
+  },
+  /**
+   * Resolves a single key by walking up the inherited chain.
+   * Returns the first defined value found, or undefined.
+   */
+  getInheritedConfig(key) {
+    const own = ownState.get(this);
+    if (own && key in own) {
+      return own[key];
+    }
+    const parent = parentRef.get(this);
+    if (parent && typeof parent.getInheritedConfig === "function") {
+      return parent.getInheritedConfig(key);
+    }
+    return void 0;
+  }
+});
+
+// src/mixin/Hookable.ts
+var hookStore = /* @__PURE__ */ new WeakMap();
+function getHookMap(inst) {
+  let map = hookStore.get(inst);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    hookStore.set(inst, map);
+  }
+  return map;
+}
+function ensureEntry(inst, methodName) {
+  const map = getHookMap(inst);
+  let entry = map.get(methodName);
+  if (!entry) {
+    const original = inst[methodName];
+    if (typeof original !== "function") {
+      throw new Error(`Hookable: "${methodName}" is not a method on this instance`);
+    }
+    entry = { before: [], after: [], original, installed: false };
+    map.set(methodName, entry);
+  }
+  return entry;
+}
+function installWrapper(inst, methodName, entry) {
+  if (entry.installed) return;
+  entry.installed = true;
+  inst[methodName] = function(...args) {
+    for (const fn of entry.before) {
+      fn.apply(this, args);
+    }
+    const result = entry.original.apply(this, args);
+    for (const fn of entry.after) {
+      fn.call(this, result);
+    }
+    return result;
+  };
+}
+var Hookable = define("Ext.mixin.Hookable", {
+  /**
+   * Adds a function that runs BEFORE the named method.
+   * The hook receives the same arguments as the method.
+   */
+  addBeforeHook(methodName, fn) {
+    const entry = ensureEntry(this, methodName);
+    entry.before.push(fn);
+    installWrapper(this, methodName, entry);
+  },
+  /**
+   * Adds a function that runs AFTER the named method.
+   * The hook receives the method's return value as its single argument.
+   */
+  addAfterHook(methodName, fn) {
+    const entry = ensureEntry(this, methodName);
+    entry.after.push(fn);
+    installWrapper(this, methodName, entry);
+  },
+  /**
+   * Removes a previously registered hook (before or after).
+   */
+  removeHook(methodName, fn) {
+    const map = hookStore.get(this);
+    if (!map) return;
+    const entry = map.get(methodName);
+    if (!entry) return;
+    entry.before = entry.before.filter((f) => f !== fn);
+    entry.after = entry.after.filter((f) => f !== fn);
+  }
+});
+
+// src/Plugin.ts
+var Plugin = class extends Base {
+  static $className = "Plugin";
+  // $configDefs for the define()-style config system
+  static $configDefs = {
+    id: "",
+    owner: null
+  };
+  /**
+   * Initialises this plugin.  Called by the Pluggable mixin after the
+   * plugin is added to an owner.
+   */
+  init(owner) {
+    this.setOwner(owner);
+  }
+  /**
+   * Override of initConfig that ensures an auto-generated id.
+   */
+  initConfig(config2) {
+    super.initConfig(config2);
+    if (!this.$configInitialized.has("id") || !this._id) {
+      const setter = `set${capitalize("id")}`;
+      if (typeof this[setter] === "function") {
+        this[setter](generateId("plugin"));
+      }
+    }
+  }
+};
+
+// src/mixin/Pluggable.ts
+var pluginStore = /* @__PURE__ */ new WeakMap();
+function getPlugins(inst) {
+  let list = pluginStore.get(inst);
+  if (!list) {
+    list = [];
+    pluginStore.set(inst, list);
+  }
+  return list;
+}
+var Pluggable = define("Ext.mixin.Pluggable", {
+  config: {
+    plugins: null
+  },
+  /**
+   * applyPlugins: processes the raw plugins config array.
+   * Each entry can be a Plugin instance, a config object with type/xtype,
+   * or will be passed through Factoryable.
+   */
+  applyPlugins(plugins) {
+    if (!plugins || !Array.isArray(plugins)) return null;
+    const list = getPlugins(this);
+    for (const pluginCfg of plugins) {
+      let plugin;
+      if (pluginCfg instanceof Plugin) {
+        plugin = pluginCfg;
+      } else if (typeof pluginCfg === "object") {
+        if (pluginCfg.xtype || pluginCfg.type) {
+          plugin = Factoryable.create(pluginCfg);
+        } else {
+          plugin = new Plugin(pluginCfg);
+        }
+      } else {
+        continue;
+      }
+      plugin.init(this);
+      list.push(plugin);
+    }
+    if (!this.$pluggableHooked) {
+      this.$pluggableHooked = true;
+      this.$destroyHooks.push(() => {
+        const l = pluginStore.get(this);
+        if (l) {
+          for (const p of l) {
+            if (!p.isDestroyed) p.destroy();
+          }
+          l.length = 0;
+        }
+      });
+    }
+    return plugins;
+  },
+  /**
+   * Returns the plugin with the given id, or undefined.
+   */
+  getPlugin(id) {
+    const list = pluginStore.get(this);
+    if (!list) return void 0;
+    return list.find((p) => !p.isDestroyed && p.getId() === id);
+  },
+  /**
+   * Adds a plugin to this instance.  Calls plugin.init(this).
+   */
+  addPlugin(plugin) {
+    const list = getPlugins(this);
+    plugin.init(this);
+    list.push(plugin);
+    if (!this.$pluggableHooked) {
+      this.$pluggableHooked = true;
+      this.$destroyHooks.push(() => {
+        const l = pluginStore.get(this);
+        if (l) {
+          for (const p of l) {
+            if (!p.isDestroyed) p.destroy();
+          }
+          l.length = 0;
+        }
+      });
+    }
+  },
+  /**
+   * Removes a plugin from this instance.  Destroys the plugin.
+   */
+  removePlugin(plugin) {
+    const list = pluginStore.get(this);
+    if (!list) return;
+    const idx = list.indexOf(plugin);
+    if (idx !== -1) {
+      list.splice(idx, 1);
+    }
+    plugin.destroy();
+  }
+});
+
+// src/event/Event.ts
+var ExtEvent = class {
+  eventName;
+  source;
+  timestamp;
+  defaultPrevented = false;
+  propagationStopped = false;
+  constructor(eventName, source) {
+    this.eventName = eventName;
+    this.source = source;
+    this.timestamp = performance.now();
+  }
+  preventDefault() {
+    this.defaultPrevented = true;
+  }
+  stopPropagation() {
+    this.propagationStopped = true;
+  }
+  /** Convenience: prevents default AND stops propagation. */
+  stopEvent() {
+    this.defaultPrevented = true;
+    this.propagationStopped = true;
+  }
+};
+
+// src/event/Observable.ts
+var stateMap = /* @__PURE__ */ new WeakMap();
+function getState(inst) {
+  let state = stateMap.get(inst);
+  if (!state) {
+    state = {
+      listeners: /* @__PURE__ */ new Map(),
+      suspendCount: 0,
+      queueSuspended: false,
+      eventQueue: [],
+      managedListeners: []
+    };
+    stateMap.set(inst, state);
+  }
+  return state;
+}
+function getListeners(state, eventName) {
+  let list = state.listeners.get(eventName);
+  if (!list) {
+    list = [];
+    state.listeners.set(eventName, list);
+  }
+  return list;
+}
+function insertListener(list, entry, prepend) {
+  const p = entry.priority;
+  let idx;
+  if (prepend) {
+    idx = list.findIndex((e) => e.priority < p);
+  } else {
+    idx = list.findIndex((e) => e.priority < p);
+  }
+  if (idx === -1) {
+    if (prepend) {
+      idx = list.findIndex((e) => e.priority <= p);
+      if (idx === -1) list.push(entry);
+      else list.splice(idx, 0, entry);
+    } else {
+      list.push(entry);
+    }
+  } else {
+    if (prepend) {
+      while (idx > 0 && list[idx - 1].priority === p) idx--;
+      list.splice(idx, 0, entry);
+    } else {
+      list.splice(idx, 0, entry);
+    }
+  }
+}
+function doFireEvent(inst, eventName, args) {
+  const state = getState(inst);
+  if (state.suspendCount > 0) {
+    if (state.queueSuspended) {
+      state.eventQueue.push({ eventName, args });
+    }
+    return true;
+  }
+  const list = state.listeners.get(eventName);
+  if (!list || list.length === 0) return true;
+  const snapshot = [...list];
+  let cancelled = false;
+  for (const entry of snapshot) {
+    if (!list.includes(entry)) continue;
+    const callArgs = entry.args ? [...entry.args, ...args] : args;
+    const scope = entry.scope;
+    if (entry.delay > 0) {
+      setTimeout(() => entry.fn.apply(scope, callArgs), entry.delay);
+      if (entry.single) removeEntry(list, entry);
+      continue;
+    }
+    if (entry.buffer > 0) {
+      if (entry.bufferTimerId !== void 0) {
+        clearTimeout(entry.bufferTimerId);
+      }
+      entry.bufferTimerId = setTimeout(() => {
+        entry.bufferTimerId = void 0;
+        entry.fn.apply(scope, callArgs);
+      }, entry.buffer);
+      if (entry.single) removeEntry(list, entry);
+      continue;
+    }
+    const result = entry.fn.apply(scope, callArgs);
+    if (entry.single) {
+      removeEntry(list, entry);
+    }
+    if (result === false) {
+      cancelled = true;
+    }
+  }
+  return !cancelled;
+}
+function removeEntry(list, entry) {
+  const idx = list.indexOf(entry);
+  if (idx !== -1) list.splice(idx, 1);
+}
+function findEntry(list, fn, scope) {
+  return list.find(
+    (e) => e.fn === fn && e.scope === scope
+  );
+}
+var Observable = define("Ext.mixin.Observable", {
+  // ----- on (with overloads) -----
+  on(eventNameOrMap, handlerOrScope, scope, options) {
+    if (typeof eventNameOrMap === "object" && eventNameOrMap !== null) {
+      const map = eventNameOrMap;
+      const mapScope = handlerOrScope;
+      for (const [evName, handler2] of Object.entries(map)) {
+        this.on(evName, handler2, mapScope);
+      }
+      return;
+    }
+    const eventName = eventNameOrMap;
+    const handler = handlerOrScope;
+    const opts = options ?? {};
+    const state = getState(this);
+    const list = getListeners(state, eventName);
+    const entry = {
+      fn: handler,
+      scope,
+      priority: opts.priority ?? 0,
+      single: opts.single ?? false,
+      delay: opts.delay ?? 0,
+      buffer: opts.buffer ?? 0,
+      args: opts.args
+    };
+    insertListener(list, entry, opts.prepend ?? false);
+    if (opts.destroyable) {
+      return {
+        destroy: () => {
+          removeEntry(list, entry);
+        }
+      };
+    }
+  },
+  // ----- un -----
+  un(eventName, handler, scope) {
+    const state = getState(this);
+    const list = state.listeners.get(eventName);
+    if (!list) return;
+    const entry = findEntry(list, handler, scope);
+    if (entry) removeEntry(list, entry);
+  },
+  // ----- aliases -----
+  addListener(...args) {
+    return this.on(...args);
+  },
+  removeListener(...args) {
+    return this.un(...args);
+  },
+  // ----- fireEvent -----
+  fireEvent(eventName, ...args) {
+    return doFireEvent(this, eventName, args);
+  },
+  // ----- fireEventArgs -----
+  fireEventArgs(eventName, args) {
+    return doFireEvent(this, eventName, args);
+  },
+  // ----- fireEventedAction -----
+  fireEventedAction(eventName, args, beforeFn, afterFn, scope) {
+    const beforeResult = doFireEvent(this, `before${eventName}`, args);
+    if (!beforeResult) return;
+    beforeFn.apply(scope, args);
+    doFireEvent(this, eventName, args);
+    afterFn.apply(scope, args);
+  },
+  // ----- suspendEvents -----
+  suspendEvents(queueSuspended) {
+    const state = getState(this);
+    state.suspendCount++;
+    if (queueSuspended) {
+      state.queueSuspended = true;
+    }
+  },
+  // ----- resumeEvents -----
+  resumeEvents(discardQueue) {
+    const state = getState(this);
+    if (state.suspendCount > 0) {
+      state.suspendCount--;
+    }
+    if (state.suspendCount === 0) {
+      if (!discardQueue && state.queueSuspended) {
+        const queue = state.eventQueue.splice(0);
+        state.queueSuspended = false;
+        for (const qe of queue) {
+          doFireEvent(this, qe.eventName, qe.args);
+        }
+      } else {
+        state.eventQueue.length = 0;
+        state.queueSuspended = false;
+      }
+    }
+  },
+  // ----- isSuspended -----
+  isSuspended() {
+    return getState(this).suspendCount > 0;
+  },
+  // ----- hasListener -----
+  hasListener(eventName) {
+    const state = stateMap.get(this);
+    if (!state) return false;
+    const list = state.listeners.get(eventName);
+    return !!list && list.length > 0;
+  },
+  // ----- clearListeners -----
+  clearListeners() {
+    const state = stateMap.get(this);
+    if (state) {
+      state.listeners.clear();
+      state.eventQueue.length = 0;
+    }
+  },
+  // ----- relayEvents -----
+  relayEvents(origin, events, prefix) {
+    const handlers = [];
+    const self = this;
+    for (const eventName of events) {
+      const targetName = (prefix ?? "") + eventName;
+      const fn = (...args) => {
+        doFireEvent(self, targetName, args);
+      };
+      origin.on(eventName, fn);
+      handlers.push({ eventName, fn });
+    }
+    return {
+      destroy() {
+        for (const { eventName, fn } of handlers) {
+          origin.un(eventName, fn);
+        }
+        handlers.length = 0;
+      }
+    };
+  },
+  // ----- mon (managed listener) -----
+  mon(target, eventName, handler, scope) {
+    const state = getState(this);
+    target.on(eventName, handler, scope);
+    state.managedListeners.push({ target, eventName, fn: handler, scope });
+  },
+  // ----- mun (remove managed listener) -----
+  mun(target, eventName, handler) {
+    const state = getState(this);
+    target.un(eventName, handler);
+    state.managedListeners = state.managedListeners.filter(
+      (ml) => !(ml.target === target && ml.eventName === eventName && ml.fn === handler)
+    );
+  }
+});
+var hookedInstances = /* @__PURE__ */ new WeakSet();
+var obsProto = Observable.prototype;
+function installDestroyHook(inst) {
+  if (hookedInstances.has(inst)) return;
+  hookedInstances.add(inst);
+  inst.$destroyHooks.push(() => {
+    const state = stateMap.get(inst);
+    if (state) {
+      state.listeners.clear();
+      state.eventQueue.length = 0;
+      for (const ml of state.managedListeners) {
+        ml.target.un(ml.eventName, ml.fn, ml.scope);
+      }
+      state.managedListeners.length = 0;
+    }
+  });
+}
+var origOn = obsProto.on;
+obsProto.on = function(...args) {
+  installDestroyHook(this);
+  return origOn.apply(this, args);
+};
+var origMon = obsProto.mon;
+obsProto.mon = function(...args) {
+  installDestroyHook(this);
+  return origMon.apply(this, args);
+};
+
+// src/event/Destroyable.ts
+var DestroyableUtil = {
+  /**
+   * Returns a single {@link Destroyable} whose `destroy()` method calls
+   * `destroy()` on every item.  The combined handle is idempotent — second
+   * and subsequent calls are no-ops.
+   */
+  combine(...items) {
+    let destroyed = false;
+    return {
+      destroy() {
+        if (destroyed) return;
+        destroyed = true;
+        for (const item of items) {
+          item.destroy();
+        }
+      }
+    };
+  }
+};
+
+// src/event/EventDomain.ts
+var domainRegistry = /* @__PURE__ */ new Map();
+var EventDomain = class {
+  name;
+  matchFn;
+  registeredListeners = [];
+  constructor(name, matchFn) {
+    this.name = name;
+    this.matchFn = matchFn;
+  }
+  // -- Static registry ----------------------------------------------------
+  static register(name, domain) {
+    domainRegistry.set(name, domain);
+  }
+  static get(name) {
+    return domainRegistry.get(name);
+  }
+  // -- Instance API -------------------------------------------------------
+  /**
+   * Returns `true` if `target` belongs to this domain.
+   */
+  match(target) {
+    return this.matchFn(target);
+  }
+  /**
+   * Registers a controller-style listener config.
+   *
+   * ```ts
+   * domain.listen({
+   *   '#myButton': { click: handler },
+   *   'MyApp.view.Panel': { collapse: handler },
+   * });
+   * ```
+   *
+   * Returns a {@link Destroyable} that removes all registered listeners.
+   */
+  listen(config2) {
+    const entries2 = [];
+    for (const [selector, events] of Object.entries(config2)) {
+      for (const [eventName, handler] of Object.entries(events)) {
+        const entry = { selector, eventName, handler };
+        entries2.push(entry);
+        this.registeredListeners.push(entry);
+      }
+    }
+    return {
+      destroy: () => {
+        for (const entry of entries2) {
+          const idx = this.registeredListeners.indexOf(entry);
+          if (idx !== -1) this.registeredListeners.splice(idx, 1);
+        }
+        entries2.length = 0;
+      }
+    };
+  }
+  /**
+   * Dispatches an event from `source` through this domain.
+   * All registered listeners whose selector matches are called.
+   */
+  dispatch(source, eventName, args) {
+    if (!this.match(source)) return;
+    for (const entry of this.registeredListeners) {
+      if (entry.eventName !== eventName) continue;
+      if (!this.matchesSelector(source, entry.selector)) continue;
+      entry.handler.apply(void 0, args);
+    }
+  }
+  // -- Selector matching --------------------------------------------------
+  matchesSelector(target, selector) {
+    if (selector.startsWith("#")) {
+      const id = selector.slice(1);
+      const targetId = typeof target.getItemId === "function" ? target.getItemId() : typeof target.getId === "function" ? target.getId() : void 0;
+      return targetId === id;
+    }
+    return target.$className === selector;
+  }
+};
+
+// src/event/EventBus.ts
+function matchPattern(pattern, channel) {
+  if (pattern === "**") return true;
+  if (pattern.endsWith(".**")) {
+    const prefix = pattern.slice(0, -3);
+    return channel.startsWith(prefix + ".");
+  }
+  if (pattern.endsWith(".*")) {
+    const prefix = pattern.slice(0, -2);
+    if (!channel.startsWith(prefix + ".")) return false;
+    const rest = channel.slice(prefix.length + 1);
+    return rest.length > 0 && !rest.includes(".");
+  }
+  return pattern === channel;
+}
+var EventBusImpl = class {
+  subscriptions = [];
+  /**
+   * Publishes a message to a channel.  All matching subscribers are called.
+   */
+  publish(channel, ...args) {
+    const snapshot = [...this.subscriptions];
+    for (const sub of snapshot) {
+      if (matchPattern(sub.pattern, channel)) {
+        sub.handler.apply(sub.scope, args);
+      }
+    }
+  }
+  /**
+   * Subscribes to a channel (exact or wildcard pattern).
+   * Returns a {@link Destroyable} handle.
+   */
+  subscribe(channel, handler, scope) {
+    const sub = { pattern: channel, handler, scope };
+    this.subscriptions.push(sub);
+    return {
+      destroy: () => {
+        const idx = this.subscriptions.indexOf(sub);
+        if (idx !== -1) this.subscriptions.splice(idx, 1);
+      }
+    };
+  }
+  /**
+   * Removes a specific subscription by handler reference.
+   */
+  unsubscribe(channel, handler) {
+    const idx = this.subscriptions.findIndex(
+      (s) => s.pattern === channel && s.handler === handler
+    );
+    if (idx !== -1) this.subscriptions.splice(idx, 1);
+  }
+};
+var EventBus = new EventBusImpl();
+
+// src/event/DomEvent.ts
+var tracked = [];
+var EventManager = {
+  // ----- on -----
+  /**
+   * Registers a DOM event listener.  The listener is tracked for
+   * bulk removal via {@link removeAll}.
+   *
+   * Returns a {@link Destroyable} handle.
+   */
+  on(element, eventName, handler, options) {
+    element.addEventListener(eventName, handler, options);
+    const entry = { element, eventName, handler, options };
+    tracked.push(entry);
+    return {
+      destroy() {
+        element.removeEventListener(eventName, handler, options);
+        const idx = tracked.indexOf(entry);
+        if (idx !== -1) tracked.splice(idx, 1);
+      }
+    };
+  },
+  // ----- un -----
+  /**
+   * Removes a DOM event listener.
+   */
+  un(element, eventName, handler) {
+    element.removeEventListener(eventName, handler);
+    const idx = tracked.findIndex(
+      (t) => t.element === element && t.eventName === eventName && t.handler === handler
+    );
+    if (idx !== -1) tracked.splice(idx, 1);
+  },
+  // ----- delegate -----
+  /**
+   * Event delegation: listens on `element` and fires `handler` only when
+   * the event target (or an ancestor up to `element`) matches `selector`.
+   *
+   * Uses `Element.closest()` — no IE polyfill needed.
+   */
+  delegate(element, eventName, selector, handler) {
+    const delegateHandler = (e) => {
+      const target = e.target;
+      if (!target) return;
+      const matched = target.closest(selector);
+      if (matched && element.contains(matched)) {
+        handler(e, matched);
+      }
+    };
+    return EventManager.on(element, eventName, delegateHandler);
+  },
+  // ----- onReady -----
+  /**
+   * Calls `fn` when the DOM is ready.  If it's already ready (interactive
+   * or complete), fires immediately.
+   */
+  onReady(fn) {
+    if (typeof document !== "undefined" && (document.readyState === "interactive" || document.readyState === "complete")) {
+      fn();
+    } else if (typeof document !== "undefined") {
+      document.addEventListener("DOMContentLoaded", fn, { once: true });
+    }
+  },
+  // ----- utility helpers -----
+  /** Prevents default and stops propagation. */
+  stopEvent(e) {
+    e.preventDefault();
+    e.stopPropagation();
+  },
+  /** Returns `e.pageX` (or `e.clientX` as fallback). */
+  getPageX(e) {
+    return e.pageX ?? e.clientX;
+  },
+  /** Returns `e.pageY` (or `e.clientY` as fallback). */
+  getPageY(e) {
+    return e.pageY ?? e.clientY;
+  },
+  /** Returns `e.relatedTarget`. */
+  getRelatedTarget(e) {
+    return e.relatedTarget;
+  },
+  /** Returns `e.key` (modern key value). */
+  getKeyCode(e) {
+    return e.key;
+  },
+  // ----- bulk cleanup -----
+  /**
+   * Removes all listeners registered via {@link on} and {@link delegate}.
+   */
+  removeAll() {
+    for (const entry of tracked) {
+      entry.element.removeEventListener(entry.eventName, entry.handler, entry.options);
+    }
+    tracked.length = 0;
+  }
+};
+
+// src/event/GestureRecognizer.ts
+var TAP_MAX_DURATION = 400;
+var TAP_MAX_DISTANCE = 15;
+var DOUBLETAP_INTERVAL = 300;
+var LONGPRESS_DURATION = 500;
+var SWIPE_MIN_DISTANCE = 50;
+function distance(x1, y1, x2, y2) {
+  return Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
+}
+function angle(x1, y1, x2, y2) {
+  return Math.atan2(y2 - y1, x2 - x1) * (180 / Math.PI);
+}
+function dispatchGesture(el, name, detail) {
+  el.dispatchEvent(new CustomEvent(name, {
+    bubbles: true,
+    cancelable: true,
+    detail: detail ?? {}
+  }));
+}
+var GestureRecognizer = class {
+  el;
+  pointers = /* @__PURE__ */ new Map();
+  longpressTimer;
+  lastTapTime = 0;
+  destroyed = false;
+  // Multi-touch initial state
+  initialPinchDistance = 0;
+  initialPinchAngle = 0;
+  // Bound handlers for removal
+  handleDown;
+  handleMove;
+  handleUp;
+  handleCancel;
+  constructor(element) {
+    this.el = element;
+    this.handleDown = (e) => this.onPointerDown(e);
+    this.handleMove = (e) => this.onPointerMove(e);
+    this.handleUp = (e) => this.onPointerUp(e);
+    this.handleCancel = (e) => this.onPointerCancel(e);
+    element.addEventListener("pointerdown", this.handleDown);
+    element.addEventListener("pointermove", this.handleMove);
+    element.addEventListener("pointerup", this.handleUp);
+    element.addEventListener("pointercancel", this.handleCancel);
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.el.removeEventListener("pointerdown", this.handleDown);
+    this.el.removeEventListener("pointermove", this.handleMove);
+    this.el.removeEventListener("pointerup", this.handleUp);
+    this.el.removeEventListener("pointercancel", this.handleCancel);
+    this.clearLongpress();
+    this.pointers.clear();
+  }
+  // ----- pointer down -----
+  onPointerDown(e) {
+    if (this.destroyed) return;
+    const state = {
+      id: e.pointerId,
+      startX: e.clientX,
+      startY: e.clientY,
+      currentX: e.clientX,
+      currentY: e.clientY,
+      startTime: Date.now()
+    };
+    this.pointers.set(e.pointerId, state);
+    if (this.pointers.size === 1) {
+      this.startLongpress(state);
+    } else if (this.pointers.size === 2) {
+      this.clearLongpress();
+      this.recordTwoPointerBaseline();
+    }
+  }
+  // ----- pointer move -----
+  onPointerMove(e) {
+    if (this.destroyed) return;
+    const state = this.pointers.get(e.pointerId);
+    if (!state) return;
+    state.currentX = e.clientX;
+    state.currentY = e.clientY;
+    const dist = distance(state.startX, state.startY, state.currentX, state.currentY);
+    if (dist > TAP_MAX_DISTANCE) {
+      this.clearLongpress();
+    }
+    if (this.pointers.size === 2) {
+      this.handleTwoPointerMove();
+    }
+  }
+  // ----- pointer up -----
+  onPointerUp(e) {
+    if (this.destroyed) return;
+    const state = this.pointers.get(e.pointerId);
+    if (!state) return;
+    state.currentX = e.clientX;
+    state.currentY = e.clientY;
+    this.clearLongpress();
+    const dt = Date.now() - state.startTime;
+    const dist = distance(state.startX, state.startY, state.currentX, state.currentY);
+    this.pointers.delete(e.pointerId);
+    if (this.pointers.size > 0) return;
+    if (dist >= SWIPE_MIN_DISTANCE && dt < 1e3) {
+      this.fireSwipe(state);
+      return;
+    }
+    if (dt < TAP_MAX_DURATION && dist < TAP_MAX_DISTANCE) {
+      const now2 = Date.now();
+      if (now2 - this.lastTapTime < DOUBLETAP_INTERVAL) {
+        dispatchGesture(this.el, "doubletap");
+        this.lastTapTime = 0;
+      } else {
+        dispatchGesture(this.el, "tap");
+        this.lastTapTime = now2;
+      }
+    }
+  }
+  // ----- pointer cancel -----
+  onPointerCancel(e) {
+    if (this.destroyed) return;
+    this.pointers.delete(e.pointerId);
+    this.clearLongpress();
+  }
+  // ----- longpress -----
+  startLongpress(state) {
+    this.clearLongpress();
+    this.longpressTimer = setTimeout(() => {
+      this.longpressTimer = void 0;
+      const current = this.pointers.get(state.id);
+      if (!current) return;
+      const dist = distance(current.startX, current.startY, current.currentX, current.currentY);
+      if (dist < TAP_MAX_DISTANCE) {
+        dispatchGesture(this.el, "longpress");
+      }
+    }, LONGPRESS_DURATION);
+  }
+  clearLongpress() {
+    if (this.longpressTimer !== void 0) {
+      clearTimeout(this.longpressTimer);
+      this.longpressTimer = void 0;
+    }
+  }
+  // ----- swipe -----
+  fireSwipe(state) {
+    const dx = state.currentX - state.startX;
+    const dy = state.currentY - state.startY;
+    const absDx = Math.abs(dx);
+    const absDy = Math.abs(dy);
+    let direction;
+    if (absDx > absDy) {
+      direction = dx > 0 ? "right" : "left";
+    } else {
+      direction = dy > 0 ? "down" : "up";
+    }
+    dispatchGesture(this.el, "swipe", {
+      direction,
+      distance: Math.max(absDx, absDy),
+      deltaX: dx,
+      deltaY: dy
+    });
+  }
+  // ----- two-pointer: pinch + rotate -----
+  recordTwoPointerBaseline() {
+    const pts = [...this.pointers.values()];
+    if (pts.length < 2) return;
+    this.initialPinchDistance = distance(
+      pts[0].currentX,
+      pts[0].currentY,
+      pts[1].currentX,
+      pts[1].currentY
+    );
+    this.initialPinchAngle = angle(
+      pts[0].currentX,
+      pts[0].currentY,
+      pts[1].currentX,
+      pts[1].currentY
+    );
+  }
+  handleTwoPointerMove() {
+    const pts = [...this.pointers.values()];
+    if (pts.length < 2) return;
+    const currentDist = distance(
+      pts[0].currentX,
+      pts[0].currentY,
+      pts[1].currentX,
+      pts[1].currentY
+    );
+    const currentAngle = angle(
+      pts[0].currentX,
+      pts[0].currentY,
+      pts[1].currentX,
+      pts[1].currentY
+    );
+    if (this.initialPinchDistance > 0) {
+      const scale = currentDist / this.initialPinchDistance;
+      dispatchGesture(this.el, "pinch", {
+        scale,
+        distance: currentDist
+      });
+    }
+    const angleDelta = currentAngle - this.initialPinchAngle;
+    dispatchGesture(this.el, "rotate", {
+      angle: angleDelta,
+      rotation: angleDelta
+    });
+  }
+};
+
+// src/event/KeyMap.ts
+function parseBinding(binding) {
+  const parts = binding.key.split("+").map((p) => p.trim());
+  let ctrl = false;
+  let alt = false;
+  let shift = false;
+  let meta = false;
+  const keyPart = parts.pop();
+  for (const mod of parts) {
+    switch (mod.toLowerCase()) {
+      case "ctrl":
+      case "control":
+        ctrl = true;
+        break;
+      case "alt":
+        alt = true;
+        break;
+      case "shift":
+        shift = true;
+        break;
+      case "meta":
+      case "cmd":
+      case "command":
+        meta = true;
+        break;
+    }
+  }
+  return {
+    raw: binding,
+    keyLower: keyPart.toLowerCase(),
+    ctrl,
+    alt,
+    shift,
+    meta
+  };
+}
+function matchesEvent(parsed, e) {
+  if (e.key.toLowerCase() !== parsed.keyLower) return false;
+  if (e.ctrlKey !== parsed.ctrl) return false;
+  if (e.altKey !== parsed.alt) return false;
+  if (e.shiftKey !== parsed.shift) return false;
+  if (e.metaKey !== parsed.meta) return false;
+  return true;
+}
+var KeyMap = class {
+  target;
+  parsedBindings = [];
+  enabled = true;
+  handleKeyDown;
+  constructor(config2) {
+    this.target = config2.target;
+    for (const b of config2.bindings) {
+      this.parsedBindings.push(parseBinding(b));
+    }
+    this.handleKeyDown = (e) => this.onKeyDown(e);
+    this.target.addEventListener("keydown", this.handleKeyDown);
+  }
+  // ----- event handler -----
+  onKeyDown(e) {
+    if (!this.enabled) return;
+    for (const parsed of this.parsedBindings) {
+      if (matchesEvent(parsed, e)) {
+        if (parsed.raw.preventDefault) {
+          e.preventDefault();
+        }
+        parsed.raw.handler.call(parsed.raw.scope, e);
+      }
+    }
+  }
+  // ----- public API -----
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+  }
+  addBinding(binding) {
+    this.parsedBindings.push(parseBinding(binding));
+  }
+  removeBinding(binding) {
+    const idx = this.parsedBindings.findIndex((p) => p.raw === binding);
+    if (idx !== -1) this.parsedBindings.splice(idx, 1);
+  }
+  destroy() {
+    this.target.removeEventListener("keydown", this.handleKeyDown);
+    this.parsedBindings.length = 0;
+    this.enabled = false;
+  }
+};
+
+// src/aria/AriaManager.ts
+var descCounter = 0;
+var liveRegion = null;
+var assertiveRegion = null;
+function ensureLiveRegion(priority) {
+  if (priority === "assertive") {
+    if (!assertiveRegion) {
+      assertiveRegion = document.createElement("div");
+      assertiveRegion.setAttribute("aria-live", "assertive");
+      assertiveRegion.setAttribute("aria-atomic", "true");
+      assertiveRegion.setAttribute("role", "status");
+      assertiveRegion.style.cssText = "position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;";
+      document.body.appendChild(assertiveRegion);
+    }
+    return assertiveRegion;
+  }
+  if (!liveRegion) {
+    liveRegion = document.createElement("div");
+    liveRegion.setAttribute("aria-live", "polite");
+    liveRegion.setAttribute("aria-atomic", "true");
+    liveRegion.setAttribute("role", "status");
+    liveRegion.style.cssText = "position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;";
+    document.body.appendChild(liveRegion);
+  }
+  return liveRegion;
+}
+var AriaManager = {
+  setRole(element, role) {
+    element.setAttribute("role", role);
+  },
+  setLabel(element, label) {
+    element.setAttribute("aria-label", label);
+  },
+  setLabelledBy(element, id) {
+    element.setAttribute("aria-labelledby", id);
+  },
+  setDescription(element, description) {
+    const id = `ext-aria-desc-${descCounter++}`;
+    const descEl = document.createElement("span");
+    descEl.id = id;
+    descEl.textContent = description;
+    descEl.style.cssText = "position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0,0,0,0);";
+    element.parentNode?.appendChild(descEl) ?? document.body.appendChild(descEl);
+    element.setAttribute("aria-describedby", id);
+  },
+  setLive(element, mode) {
+    element.setAttribute("aria-live", mode);
+  },
+  announce(message, priority = "polite") {
+    const region = ensureLiveRegion(priority);
+    region.textContent = message;
+  },
+  /** Generate a unique ID for ARIA linking. */
+  generateId(prefix = "ext-aria") {
+    return `${prefix}-${descCounter++}`;
+  }
+};
+
+// src/aria/FocusManager.ts
+var trapped = false;
+var trapContainer = null;
+var savedFocus = null;
+var keyHandler = null;
+var FOCUSABLE = 'a[href],button:not([disabled]),input:not([disabled]),select:not([disabled]),textarea:not([disabled]),[tabindex]:not([tabindex="-1"])';
+function getFocusableElements(container) {
+  return Array.from(container.querySelectorAll(FOCUSABLE));
+}
+function onKeyDown(e) {
+  if (e.key !== "Tab" || !trapContainer) return;
+  const focusable = getFocusableElements(trapContainer);
+  if (focusable.length === 0) return;
+  const first = focusable[0];
+  const last = focusable[focusable.length - 1];
+  if (e.shiftKey) {
+    if (document.activeElement === first) {
+      e.preventDefault();
+      last.focus();
+    }
+  } else {
+    if (document.activeElement === last) {
+      e.preventDefault();
+      first.focus();
+    }
+  }
+}
+var FocusManager = {
+  /**
+   * Trap focus within a container.  Tab/Shift+Tab cycle among
+   * focusable elements inside the container.
+   */
+  trapFocus(container) {
+    trapped = true;
+    trapContainer = container;
+    keyHandler = onKeyDown;
+    document.addEventListener("keydown", keyHandler);
+    const focusable = getFocusableElements(container);
+    if (focusable.length > 0) focusable[0].focus();
+  },
+  /** Release the focus trap. */
+  releaseFocus() {
+    trapped = false;
+    trapContainer = null;
+    if (keyHandler) {
+      document.removeEventListener("keydown", keyHandler);
+      keyHandler = null;
+    }
+  },
+  isTrapped() {
+    return trapped;
+  },
+  /** Save the currently focused element for later restoration. */
+  saveFocus() {
+    savedFocus = document.activeElement;
+  },
+  /** Restore focus to the previously saved element. */
+  restoreFocus() {
+    if (savedFocus && typeof savedFocus.focus === "function") {
+      savedFocus.focus();
+    }
+    savedFocus = null;
+  },
+  /** Reset all state (for tests). */
+  reset() {
+    if (keyHandler) {
+      document.removeEventListener("keydown", keyHandler);
+      keyHandler = null;
+    }
+    trapped = false;
+    trapContainer = null;
+    savedFocus = null;
+  }
+};
+
+// src/locale/Locale.ts
+var Locale = class {
+  _language;
+  _rtl;
+  _messages;
+  _numberFormat;
+  _firstDayOfWeek;
+  _pluralRules;
+  _collator;
+  _numberFormatter;
+  _dateFormatter;
+  _timeFormatter;
+  _currencyFormatter = null;
+  constructor(config2) {
+    this._language = config2.language;
+    this._rtl = config2.rtl ?? false;
+    this._messages = { ...config2.messages };
+    this._numberFormat = config2.numberFormat ?? {};
+    this._firstDayOfWeek = config2.firstDayOfWeek ?? 0;
+    this._pluralRules = config2.pluralRules ?? null;
+    this._collator = new Intl.Collator(this._language);
+    this._numberFormatter = new Intl.NumberFormat(this._language);
+    this._dateFormatter = new Intl.DateTimeFormat(this._language, {
+      year: "numeric",
+      month: "numeric",
+      day: "numeric"
+    });
+    this._timeFormatter = new Intl.DateTimeFormat(this._language, {
+      hour: "numeric",
+      minute: "numeric"
+    });
+    if (this._numberFormat.currency) {
+      this._currencyFormatter = new Intl.NumberFormat(this._language, {
+        style: "currency",
+        currency: this._numberFormat.currency
+      });
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Accessors
+  // -----------------------------------------------------------------------
+  getLanguage() {
+    return this._language;
+  }
+  isRtl() {
+    return this._rtl;
+  }
+  getDirection() {
+    return this._rtl ? "rtl" : "ltr";
+  }
+  getFirstDayOfWeek() {
+    return this._firstDayOfWeek;
+  }
+  // -----------------------------------------------------------------------
+  // Translation
+  // -----------------------------------------------------------------------
+  t(key, params) {
+    let msg = this._messages[key];
+    if (msg === void 0) return key;
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        msg = msg.replaceAll(`{${k}}`, String(v ?? ""));
+      }
+    }
+    return msg;
+  }
+  /**
+   * Translate with plural support.  Appends the plural category
+   * to the key (e.g., 'items.one', 'items.other').
+   */
+  tp(key, count, params) {
+    const category = this.getPlural(count);
+    return this.t(`${key}.${category}`, params);
+  }
+  // -----------------------------------------------------------------------
+  // Plural rules
+  // -----------------------------------------------------------------------
+  getPlural(count) {
+    if (this._pluralRules) return this._pluralRules(count);
+    try {
+      return new Intl.PluralRules(this._language).select(count);
+    } catch {
+      return count === 1 ? "one" : "other";
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Number formatting
+  // -----------------------------------------------------------------------
+  formatNumber(value) {
+    return this._numberFormatter.format(value);
+  }
+  formatCurrency(value) {
+    if (this._currencyFormatter) return this._currencyFormatter.format(value);
+    return this._numberFormatter.format(value);
+  }
+  // -----------------------------------------------------------------------
+  // Date / time formatting
+  // -----------------------------------------------------------------------
+  formatDate(date) {
+    return this._dateFormatter.format(date);
+  }
+  formatTime(date) {
+    return this._timeFormatter.format(date);
+  }
+  // -----------------------------------------------------------------------
+  // Collation / sorting
+  // -----------------------------------------------------------------------
+  compare(a, b) {
+    return this._collator.compare(a, b);
+  }
+};
+
+// src/locale/LocaleManager.ts
+var locales = /* @__PURE__ */ new Map();
+var activeLocale = null;
+var listeners = {};
+function fire(event, ...args) {
+  (listeners[event] ?? []).forEach((fn) => fn(...args));
+}
+var LocaleManager = {
+  register(locale) {
+    locales.set(locale.getLanguage(), locale);
+  },
+  setLocale(language) {
+    const locale = locales.get(language);
+    if (!locale) return;
+    activeLocale = locale;
+    const root = document.documentElement;
+    root.setAttribute("lang", language);
+    root.setAttribute("dir", locale.getDirection());
+    fire("localechange", locale, language);
+  },
+  getLocale() {
+    return activeLocale;
+  },
+  t(key, params) {
+    if (!activeLocale) return key;
+    return activeLocale.t(key, params);
+  },
+  getDirection() {
+    return activeLocale?.getDirection() ?? "ltr";
+  },
+  on(event, fn) {
+    (listeners[event] ??= []).push(fn);
+  },
+  off(event, fn) {
+    const list = listeners[event];
+    if (!list) return;
+    const idx = list.indexOf(fn);
+    if (idx >= 0) list.splice(idx, 1);
+  },
+  reset() {
+    activeLocale = null;
+    locales.clear();
+    for (const key of Object.keys(listeners)) listeners[key] = [];
+    document.documentElement.removeAttribute("dir");
+    document.documentElement.removeAttribute("lang");
+  }
+};
+
+// src/locale/bundles/en-US.ts
+var enUS = new Locale({
+  language: "en-US",
+  rtl: false,
+  firstDayOfWeek: 0,
+  numberFormat: { currency: "USD" },
+  messages: {
+    // Buttons
+    "btn.ok": "OK",
+    "btn.cancel": "Cancel",
+    "btn.yes": "Yes",
+    "btn.no": "No",
+    "btn.save": "Save",
+    "btn.close": "Close",
+    "btn.apply": "Apply",
+    "btn.reset": "Reset",
+    // Grid
+    "grid.noData": "No data to display",
+    "grid.loading": "Loading...",
+    "grid.page": "Page {page} of {total}",
+    "grid.pageSize": "Items per page",
+    // Form validation
+    "validation.required": "This field is required",
+    "validation.minLength": "Minimum length is {min} characters",
+    "validation.maxLength": "Maximum length is {max} characters",
+    "validation.email": "This is not a valid email address",
+    "validation.range": "Value must be between {min} and {max}",
+    "validation.format": "Invalid format",
+    // Date picker — months
+    "datepicker.months.0": "January",
+    "datepicker.months.1": "February",
+    "datepicker.months.2": "March",
+    "datepicker.months.3": "April",
+    "datepicker.months.4": "May",
+    "datepicker.months.5": "June",
+    "datepicker.months.6": "July",
+    "datepicker.months.7": "August",
+    "datepicker.months.8": "September",
+    "datepicker.months.9": "October",
+    "datepicker.months.10": "November",
+    "datepicker.months.11": "December",
+    // Date picker — days
+    "datepicker.days.0": "Sunday",
+    "datepicker.days.1": "Monday",
+    "datepicker.days.2": "Tuesday",
+    "datepicker.days.3": "Wednesday",
+    "datepicker.days.4": "Thursday",
+    "datepicker.days.5": "Friday",
+    "datepicker.days.6": "Saturday",
+    // Date picker — short days
+    "datepicker.daysShort.0": "Sun",
+    "datepicker.daysShort.1": "Mon",
+    "datepicker.daysShort.2": "Tue",
+    "datepicker.daysShort.3": "Wed",
+    "datepicker.daysShort.4": "Thu",
+    "datepicker.daysShort.5": "Fri",
+    "datepicker.daysShort.6": "Sat",
+    // MessageBox
+    "messagebox.alert.title": "Alert",
+    "messagebox.confirm.title": "Confirm",
+    "messagebox.prompt.title": "Prompt",
+    // Misc
+    "loading": "Loading...",
+    "error": "Error"
+  }
+});
+
+// src/locale/bundles/es-ES.ts
+var esES = new Locale({
+  language: "es-ES",
+  rtl: false,
+  firstDayOfWeek: 1,
+  numberFormat: { currency: "EUR" },
+  messages: {
+    "btn.ok": "Aceptar",
+    "btn.cancel": "Cancelar",
+    "btn.yes": "S\xED",
+    "btn.no": "No",
+    "btn.save": "Guardar",
+    "btn.close": "Cerrar",
+    "btn.apply": "Aplicar",
+    "btn.reset": "Restablecer",
+    "grid.noData": "No hay datos para mostrar",
+    "grid.loading": "Cargando...",
+    "grid.page": "P\xE1gina {page} de {total}",
+    "grid.pageSize": "Elementos por p\xE1gina",
+    "validation.required": "Este campo es obligatorio",
+    "validation.minLength": "La longitud m\xEDnima es de {min} caracteres",
+    "validation.maxLength": "La longitud m\xE1xima es de {max} caracteres",
+    "validation.email": "No es una direcci\xF3n de correo v\xE1lida",
+    "validation.range": "El valor debe estar entre {min} y {max}",
+    "validation.format": "Formato inv\xE1lido",
+    "datepicker.months.0": "Enero",
+    "datepicker.months.1": "Febrero",
+    "datepicker.months.2": "Marzo",
+    "datepicker.months.3": "Abril",
+    "datepicker.months.4": "Mayo",
+    "datepicker.months.5": "Junio",
+    "datepicker.months.6": "Julio",
+    "datepicker.months.7": "Agosto",
+    "datepicker.months.8": "Septiembre",
+    "datepicker.months.9": "Octubre",
+    "datepicker.months.10": "Noviembre",
+    "datepicker.months.11": "Diciembre",
+    "datepicker.days.0": "Domingo",
+    "datepicker.days.1": "Lunes",
+    "datepicker.days.2": "Martes",
+    "datepicker.days.3": "Mi\xE9rcoles",
+    "datepicker.days.4": "Jueves",
+    "datepicker.days.5": "Viernes",
+    "datepicker.days.6": "S\xE1bado",
+    "datepicker.daysShort.0": "Dom",
+    "datepicker.daysShort.1": "Lun",
+    "datepicker.daysShort.2": "Mar",
+    "datepicker.daysShort.3": "Mi\xE9",
+    "datepicker.daysShort.4": "Jue",
+    "datepicker.daysShort.5": "Vie",
+    "datepicker.daysShort.6": "S\xE1b",
+    "messagebox.alert.title": "Alerta",
+    "messagebox.confirm.title": "Confirmar",
+    "messagebox.prompt.title": "Aviso",
+    "loading": "Cargando...",
+    "error": "Error"
+  }
+});
+
+// src/locale/bundles/ar-SA.ts
+var arSA = new Locale({
+  language: "ar-SA",
+  rtl: true,
+  firstDayOfWeek: 6,
+  numberFormat: { currency: "SAR" },
+  messages: {
+    "btn.ok": "\u0645\u0648\u0627\u0641\u0642",
+    "btn.cancel": "\u0625\u0644\u063A\u0627\u0621",
+    "btn.yes": "\u0646\u0639\u0645",
+    "btn.no": "\u0644\u0627",
+    "btn.save": "\u062D\u0641\u0638",
+    "btn.close": "\u0625\u063A\u0644\u0627\u0642",
+    "btn.apply": "\u062A\u0637\u0628\u064A\u0642",
+    "btn.reset": "\u0625\u0639\u0627\u062F\u0629 \u062A\u0639\u064A\u064A\u0646",
+    "grid.noData": "\u0644\u0627 \u062A\u0648\u062C\u062F \u0628\u064A\u0627\u0646\u0627\u062A \u0644\u0644\u0639\u0631\u0636",
+    "grid.loading": "\u062C\u0627\u0631\u064A \u0627\u0644\u062A\u062D\u0645\u064A\u0644...",
+    "grid.page": "\u0635\u0641\u062D\u0629 {page} \u0645\u0646 {total}",
+    "grid.pageSize": "\u0639\u0646\u0627\u0635\u0631 \u0641\u064A \u0627\u0644\u0635\u0641\u062D\u0629",
+    "validation.required": "\u0647\u0630\u0627 \u0627\u0644\u062D\u0642\u0644 \u0645\u0637\u0644\u0648\u0628",
+    "validation.minLength": "\u0627\u0644\u062D\u062F \u0627\u0644\u0623\u062F\u0646\u0649 \u0644\u0644\u0637\u0648\u0644 \u0647\u0648 {min} \u062D\u0631\u0641\u064B\u0627",
+    "validation.maxLength": "\u0627\u0644\u062D\u062F \u0627\u0644\u0623\u0642\u0635\u0649 \u0644\u0644\u0637\u0648\u0644 \u0647\u0648 {max} \u062D\u0631\u0641\u064B\u0627",
+    "validation.email": "\u0647\u0630\u0627 \u0644\u064A\u0633 \u0639\u0646\u0648\u0627\u0646 \u0628\u0631\u064A\u062F \u0625\u0644\u0643\u062A\u0631\u0648\u0646\u064A \u0635\u0627\u0644\u062D\u064B\u0627",
+    "validation.range": "\u064A\u062C\u0628 \u0623\u0646 \u062A\u0643\u0648\u0646 \u0627\u0644\u0642\u064A\u0645\u0629 \u0628\u064A\u0646 {min} \u0648 {max}",
+    "validation.format": "\u062A\u0646\u0633\u064A\u0642 \u063A\u064A\u0631 \u0635\u0627\u0644\u062D",
+    "datepicker.months.0": "\u064A\u0646\u0627\u064A\u0631",
+    "datepicker.months.1": "\u0641\u0628\u0631\u0627\u064A\u0631",
+    "datepicker.months.2": "\u0645\u0627\u0631\u0633",
+    "datepicker.months.3": "\u0623\u0628\u0631\u064A\u0644",
+    "datepicker.months.4": "\u0645\u0627\u064A\u0648",
+    "datepicker.months.5": "\u064A\u0648\u0646\u064A\u0648",
+    "datepicker.months.6": "\u064A\u0648\u0644\u064A\u0648",
+    "datepicker.months.7": "\u0623\u063A\u0633\u0637\u0633",
+    "datepicker.months.8": "\u0633\u0628\u062A\u0645\u0628\u0631",
+    "datepicker.months.9": "\u0623\u0643\u062A\u0648\u0628\u0631",
+    "datepicker.months.10": "\u0646\u0648\u0641\u0645\u0628\u0631",
+    "datepicker.months.11": "\u062F\u064A\u0633\u0645\u0628\u0631",
+    "datepicker.days.0": "\u0627\u0644\u0623\u062D\u062F",
+    "datepicker.days.1": "\u0627\u0644\u0625\u062B\u0646\u064A\u0646",
+    "datepicker.days.2": "\u0627\u0644\u062B\u0644\u0627\u062B\u0627\u0621",
+    "datepicker.days.3": "\u0627\u0644\u0623\u0631\u0628\u0639\u0627\u0621",
+    "datepicker.days.4": "\u0627\u0644\u062E\u0645\u064A\u0633",
+    "datepicker.days.5": "\u0627\u0644\u062C\u0645\u0639\u0629",
+    "datepicker.days.6": "\u0627\u0644\u0633\u0628\u062A",
+    "datepicker.daysShort.0": "\u0623\u062D\u062F",
+    "datepicker.daysShort.1": "\u0625\u062B\u0646",
+    "datepicker.daysShort.2": "\u062B\u0644\u0627",
+    "datepicker.daysShort.3": "\u0623\u0631\u0628",
+    "datepicker.daysShort.4": "\u062E\u0645\u064A",
+    "datepicker.daysShort.5": "\u062C\u0645\u0639",
+    "datepicker.daysShort.6": "\u0633\u0628\u062A",
+    "messagebox.alert.title": "\u062A\u0646\u0628\u064A\u0647",
+    "messagebox.confirm.title": "\u062A\u0623\u0643\u064A\u062F",
+    "messagebox.prompt.title": "\u0625\u062F\u062E\u0627\u0644",
+    "loading": "\u062C\u0627\u0631\u064A \u0627\u0644\u062A\u062D\u0645\u064A\u0644...",
+    "error": "\u062E\u0637\u0623"
+  }
+});
+
+// src/util/Sanitizer.ts
+var SAFE_TAGS = /* @__PURE__ */ new Set([
+  "a",
+  "abbr",
+  "b",
+  "blockquote",
+  "br",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "dd",
+  "del",
+  "details",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "figcaption",
+  "figure",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "hr",
+  "i",
+  "img",
+  "ins",
+  "kbd",
+  "label",
+  "li",
+  "mark",
+  "ol",
+  "p",
+  "pre",
+  "q",
+  "s",
+  "samp",
+  "small",
+  "span",
+  "strong",
+  "sub",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "tr",
+  "u",
+  "ul",
+  "var",
+  "wbr"
+]);
+var SAFE_ATTRS = /* @__PURE__ */ new Set([
+  "align",
+  "alt",
+  "class",
+  "colspan",
+  "dir",
+  "height",
+  "href",
+  "id",
+  "lang",
+  "name",
+  "role",
+  "rowspan",
+  "scope",
+  "src",
+  "style",
+  "tabindex",
+  "target",
+  "title",
+  "type",
+  "valign",
+  "width",
+  // ARIA
+  "aria-controls",
+  "aria-describedby",
+  "aria-disabled",
+  "aria-expanded",
+  "aria-haspopup",
+  "aria-hidden",
+  "aria-label",
+  "aria-labelledby",
+  "aria-live",
+  "aria-modal",
+  "aria-pressed",
+  "aria-selected",
+  "aria-sort"
+]);
+var SAFE_URL_PATTERN = /^(?:https?|mailto|tel|#):/i;
+var DATA_URL_PATTERN = /^data:image\/(?:png|gif|jpeg|webp|svg\+xml);base64,/i;
+function isUrlSafe(attr, value) {
+  if (attr !== "href" && attr !== "src") return true;
+  const trimmed = value.trim();
+  if (trimmed.startsWith("#") || trimmed.startsWith("/")) return true;
+  return SAFE_URL_PATTERN.test(trimmed) || DATA_URL_PATTERN.test(trimmed);
+}
+var DANGEROUS_TAGS = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "iframe",
+  "object",
+  "embed",
+  "applet",
+  "base",
+  "link",
+  "meta",
+  "noscript",
+  "template"
+]);
+function sanitizeNode(node, doc) {
+  if (node.nodeType === 3) {
+    return doc.createTextNode(node.textContent ?? "");
+  }
+  if (node.nodeType !== 1) return null;
+  const el = node;
+  const tagName = el.tagName.toLowerCase();
+  if (DANGEROUS_TAGS.has(tagName)) return null;
+  if (!SAFE_TAGS.has(tagName)) {
+    const frag = doc.createDocumentFragment();
+    for (const child of Array.from(el.childNodes)) {
+      const cleaned = sanitizeNode(child, doc);
+      if (cleaned) frag.appendChild(cleaned);
+    }
+    return frag;
+  }
+  const cleanEl = doc.createElement(tagName);
+  for (const attr of Array.from(el.attributes)) {
+    const name = attr.name.toLowerCase();
+    if (!SAFE_ATTRS.has(name)) continue;
+    if (name.startsWith("on")) continue;
+    if (!isUrlSafe(name, attr.value)) continue;
+    cleanEl.setAttribute(name, attr.value);
+  }
+  for (const child of Array.from(el.childNodes)) {
+    const cleaned = sanitizeNode(child, doc);
+    if (cleaned) cleanEl.appendChild(cleaned);
+  }
+  return cleanEl;
+}
+var Sanitizer = {
+  /**
+   * Sanitize an HTML string by removing dangerous tags and attributes.
+   * Uses a whitelist approach — only known-safe elements pass through.
+   *
+   * @param html - Raw HTML string
+   * @returns Sanitized HTML string safe for innerHTML
+   */
+  sanitize(html) {
+    if (!html) return "";
+    if (!/</.test(html)) return html;
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(`<body>${html}</body>`, "text/html");
+    const body = doc.body;
+    const frag = doc.createDocumentFragment();
+    for (const child of Array.from(body.childNodes)) {
+      const cleaned = sanitizeNode(child, doc);
+      if (cleaned) frag.appendChild(cleaned);
+    }
+    const wrapper = doc.createElement("div");
+    wrapper.appendChild(frag);
+    return wrapper.innerHTML;
+  },
+  /**
+   * Escape HTML special characters for safe text insertion.
+   *
+   * @param text - Raw text
+   * @returns Escaped string safe for HTML context
+   */
+  escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+  },
+  /**
+   * Check if an HTML string contains potentially dangerous content.
+   *
+   * @param html - HTML string to check
+   * @returns true if the HTML appears safe
+   */
+  isSafe(html) {
+    const dangerous = /<script|javascript:|on\w+\s*=/i;
+    return !dangerous.test(html);
+  }
+};
+
+// src/index.ts
+var VERSION = "0.0.1";
+export {
+  AriaManager,
+  Base,
+  ClassManager,
+  Configurator,
+  DestroyableUtil,
+  EventBus,
+  EventDomain,
+  EventManager,
+  ExtEvent,
+  Factoryable,
+  FocusManager,
+  GestureRecognizer,
+  Hookable,
+  Identifiable,
+  IdentityMap,
+  Inheritable,
+  KeyMap,
+  Locale,
+  LocaleManager,
+  Observable,
+  Pluggable,
+  Plugin,
+  Sanitizer,
+  VERSION,
+  alias,
+  apply,
+  applyIf,
+  arSA,
+  bind,
+  camelCase,
+  capitalize,
+  chunk,
+  clean,
+  clone,
+  compose,
+  config,
+  contains,
+  createBarrier,
+  createBuffered,
+  createDelayed,
+  createSequence,
+  createThrottled,
+  defer,
+  define,
+  difference,
+  ellipsis,
+  emptyFn,
+  enUS,
+  entries,
+  equals,
+  esES,
+  escapeHtml,
+  escapeRegex,
+  findBy,
+  flatten,
+  flattenObject,
+  format,
+  freeze,
+  from,
+  fromEntries,
+  generateId,
+  getNestedValue,
+  groupBy,
+  htmlDecode,
+  htmlEncode,
+  identity,
+  include,
+  interceptAfter,
+  interceptBefore,
+  intersection,
+  interval,
+  isArray,
+  isBoolean,
+  isDefined,
+  isEmpty,
+  isFunction,
+  isIterable,
+  isNumber,
+  isObject,
+  isPrimitive,
+  isString,
+  kebabCase,
+  keys,
+  leftPad,
+  mapKeys,
+  mapValues,
+  max,
+  mean,
+  memoize,
+  merge,
+  min,
+  mixin,
+  namespace,
+  negate,
+  now,
+  observable,
+  omit,
+  once,
+  override,
+  partition,
+  pascalCase,
+  pick,
+  pipe,
+  pluck,
+  range,
+  remove,
+  repeat,
+  setNestedValue,
+  sortBy,
+  splitWords,
+  sum,
+  toggle,
+  trim,
+  uncapitalize,
+  unescapeHtml,
+  unflattenObject,
+  unique,
+  values
+};
+//# sourceMappingURL=index.js.map