@vicin/sigil 1.0.1 → 1.1.1

package/dist/index.mjs

@@ -0,0 +1,684 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+
+// src/core/options.ts
+var OPTIONS = {
+  labelValidation: null,
+  skipLabelInheritanceCheck: false,
+  autofillLabels: false,
+  devMarker: false,
+  registry: null,
+  useGlobalRegistry: false,
+  storeConstructor: false
+};
+var __SIGIL_REGISTRY__ = /* @__PURE__ */ Symbol.for("@Sigil.__SIGIL_REGISTRY__");
+var updateGlobalRegistry = (map) => {
+  if (map === null) delete globalThis[__SIGIL_REGISTRY__];
+  else globalThis[__SIGIL_REGISTRY__] = map;
+};
+var getGlobalRegistry = () => {
+  const val = globalThis[__SIGIL_REGISTRY__];
+  return val === void 0 ? null : val;
+};
+var SigilRegistry = class _SigilRegistry {
+  /**
+   * @param map - Map used to register 'Sigil' classes. if not passed it will be auto-generated internally.
+   */
+  constructor(map) {
+    /** Internal private registry map. */
+    __publicField(this, "_registry");
+    this._registry = map != null ? map : /* @__PURE__ */ new Map();
+  }
+  /**
+   * Return a readonly view (array) of the current registry entries.
+   *
+   * @returns An array containing all registered labels, or an empty array when registry is disabled.
+   */
+  listLabels() {
+    return this._registry ? Array.from(this._registry.keys()) : [];
+  }
+  /**
+   * Determine whether the registry currently contains `label`.
+   *
+   * @param label - The label to test.
+   * @returns `true` if present; `false` otherwise.
+   */
+  has(label) {
+    return !!this._registry && this._registry.has(label);
+  }
+  /**
+   * Get class constructor using its label.
+   *
+   * @param label - Label appended to Sigil class.
+   * @returns Reference to Sigil class constructor or null if stored with 'SigilOptions.storeConstructor = false'.
+   */
+  get(label) {
+    var _a;
+    return (_a = this._registry.get(label)) != null ? _a : null;
+  }
+  /**
+   * Register a label and class constructor in the active registry.
+   *
+   * If the label already exists then:
+   *   - In DEV builds: prints a console warning (HMR friendly) and returns early.
+   *   - In non-DEV builds: throws an Error to prevent duplicate registration.
+   *
+   * @param label - Label string to register (e.g. '@scope/pkg.ClassName').
+   * @param Class - Constructor of the class being registered.
+   * @param opts - Optional per-call overrides.
+   */
+  register(label, Class, opts) {
+    var _a, _b, _c, _d;
+    if (!OPTIONS.registry) return;
+    const storeCtor = (_a = opts == null ? void 0 : opts.storeConstructor) != null ? _a : OPTIONS.storeConstructor;
+    const devMarker = (_b = opts == null ? void 0 : opts.devMarker) != null ? _b : OPTIONS.devMarker;
+    if (this._registry.has(label)) {
+      const existing = this._registry.get(label);
+      const isLikelyHMR = (existing == null ? void 0 : existing.name) === (Class == null ? void 0 : Class.name);
+      if (devMarker) {
+        if (isLikelyHMR) {
+          console.warn(
+            `[Sigil] Duplicate label "${label}" may be due to HMR \u2014 ignore if you are sure that it's defined once.`
+          );
+        } else {
+          throw new Error(
+            `[Sigil Error] Duplicate label '${label}' (different classes: ${(_c = existing == null ? void 0 : existing.name) != null ? _c : "unknown"} vs ${(_d = Class == null ? void 0 : Class.name) != null ? _d : "unknown"}).`
+          );
+        }
+      } else {
+        throw new Error(
+          `[Sigil Error] Duplicate label '${label}' detected. Labels must be unique.`
+        );
+      }
+    } else {
+      this._registry.set(label, storeCtor ? Class : null);
+    }
+  }
+  /**
+   * Alias for 'SigilRegistry.register'.
+   *
+   * @param label - Label string to register (e.g. '@scope/pkg.ClassName').
+   * @param Class - Constructor of the class being registered.
+   * @param opts - Optional per-call overrides.
+   */
+  set(label, Class, opts) {
+    return this.register(label, Class, opts);
+  }
+  /**
+   * Unregister a previously registered class.
+   *
+   * @param label - The label to remove from the registry.
+   * @returns `true` if the label was present and removed; `false` otherwise (or when registry is disabled).
+   */
+  unregister(label) {
+    return this._registry.delete(label);
+  }
+  /**
+   * Alias for 'SigilRegistry.unregister'.
+   *
+   * @param label - The label to remove from the registry.
+   * @returns `true` if the label was present and removed; `false` otherwise (or when registry is disabled).
+   */
+  delete(label) {
+    return this.unregister(label);
+  }
+  /**
+   * Replace active registry with new one. deprecated use 'updateOptions({ registry: newRegistry })' instead.
+   *
+   * @deprecated Will be removed in v2.0.0, check https://www.npmjs.com/package/@vicin/sigil?activeTab=readme#registry for more details.
+   * @param newRegistry - New Set<string> instance to use as the active registry, or `null` to disable checks.
+   */
+  replaceRegistry(newRegistry) {
+    if (newRegistry)
+      updateOptions({ registry: new _SigilRegistry(newRegistry) });
+    else updateOptions({ registry: newRegistry });
+  }
+  /**
+   * Clear the registry completely.
+   *
+   * Useful for test teardown, or when explicitly resetting state during development.
+   * No-op when the registry is disabled.
+   */
+  clear() {
+    this._registry.clear();
+  }
+  /**
+   * Merge another SigilRegistry into this one.
+   *
+   * Entries from `other` will be registered into this registry. Duplicate labels
+   * are handled via this registry's `register` logic (i.e., will warn in DEV or
+   * throw in production).
+   *
+   * @param other - Another `SigilRegistry` whose entries will be merged into this registry.
+   */
+  merge(other) {
+    if (!OPTIONS.registry) return;
+    for (const [label, ctor] of other) this.register(label, ctor);
+  }
+  /**
+   * Return a Map-style iterator over entries: `[label, constructor]`.
+   * Equivalent to calling `registry[Symbol.iterator]()`.
+   *
+   * @returns IterableIterator of `[label, ISigil]`.
+   */
+  entries() {
+    return this._registry.entries();
+  }
+  /**
+   * Return an iterator over registered constructors.
+   *
+   * @returns IterableIterator of `ISigil` constructors.
+   */
+  values() {
+    return this._registry.values();
+  }
+  /**
+   * Return an iterator over registered labels (keys).
+   *
+   * @returns IterableIterator of `string` labels.
+   */
+  keys() {
+    return this._registry.keys();
+  }
+  /**
+   * Execute a provided function once per registry entry.
+   *
+   * @param callback - Function invoked with `(ctor, label)` for each entry.
+   * @param thisArg - Optional `this` context for the callback.
+   */
+  forEach(callback, thisArg) {
+    this._registry.forEach(
+      (ctor, label) => callback.call(thisArg, ctor, label)
+    );
+  }
+  /**
+   * Get the size (number of entries) of the active registry.
+   *
+   * @returns The number of registered labels, or 0 when registry is disabled.
+   */
+  get size() {
+    return this._registry.size;
+  }
+  /**
+   * Return an iterator over `[label, constructor]` pairs.
+   *
+   * This makes the registry compatible with `for..of` and other iterable helpers:
+   * ```ts
+   * for (const [label, ctor] of registry) { ... }
+   * ```
+   *
+   * @returns An iterable iterator that yields `[label, ISigil]` tuples.
+   */
+  [Symbol.iterator]() {
+    return this._registry[Symbol.iterator]();
+  }
+};
+var getActiveRegistry = () => {
+  const globalRegistry = getGlobalRegistry();
+  if (globalRegistry) return globalRegistry;
+  return OPTIONS.registry;
+};
+var REGISTRY = OPTIONS.registry;
+var DEFAULT_LABEL_REGEX = /^@[\w-]+(?:\/[\w-]+)*\.[A-Z][A-Za-z0-9]*$/;
+var updateOptions = (opts, mergeRegistries = true) => {
+  applyBeforeSideEffects(OPTIONS, opts, mergeRegistries);
+  for (const [k, v] of Object.entries(opts)) OPTIONS[k] = v;
+  applyAfterSideEffects(OPTIONS);
+};
+function applyBeforeSideEffects(oldOpts, newOpts, mergeRegistries) {
+  if (mergeRegistries && newOpts.registry && oldOpts.registry)
+    newOpts.registry.merge(oldOpts.registry);
+}
+function applyAfterSideEffects(opts) {
+  if (opts.useGlobalRegistry) updateGlobalRegistry(opts.registry);
+  else updateGlobalRegistry(null);
+  if (OPTIONS.registry) REGISTRY = OPTIONS.registry;
+  else REGISTRY = new SigilRegistry();
+}
+var DEFAULT_OPTIONS = {
+  labelValidation: null,
+  skipLabelInheritanceCheck: false,
+  autofillLabels: false,
+  devMarker: process.env.NODE_ENV !== "production",
+  registry: new SigilRegistry(),
+  useGlobalRegistry: true,
+  storeConstructor: true
+};
+updateOptions(DEFAULT_OPTIONS);
+
+// src/core/symbols.ts
+var __SIGIL__ = /* @__PURE__ */ Symbol.for("@Sigil.__SIGIL__");
+var __SIGIL_BASE__ = /* @__PURE__ */ Symbol.for("@Sigil.__SIGIL_BASE__");
+var __DECORATED__ = /* @__PURE__ */ Symbol.for("@Sigil.__DECORATED__");
+var __INHERITANCE_CHECKED__ = /* @__PURE__ */ Symbol.for(
+  "@Sigil.__INHERITANCE_CHECKED__"
+);
+var __LABEL__ = /* @__PURE__ */ Symbol.for("@Sigil.__LABEL__");
+var __TYPE__ = /* @__PURE__ */ Symbol.for("@Sigil.__TYPE__");
+var __TYPE_LINEAGE__ = /* @__PURE__ */ Symbol.for("@Sigil.__TYPE_LINEAGE__");
+var __TYPE_SET__ = /* @__PURE__ */ Symbol.for("@Sigil.__TYPE_SET__");
+
+// src/core/helpers.ts
+function decorateCtor(ctor, label, opts) {
+  var _a;
+  if (isDecorated(ctor))
+    throw new Error(
+      `Constructor ${ctor} is already decorated. if you are using 'withSigilTyped()' & '@WithSigil()' at the same time remove one of them.`
+    );
+  const symbol = Symbol.for(label);
+  (_a = getActiveRegistry()) == null ? void 0 : _a.register(label, ctor, opts);
+  Object.defineProperty(ctor, __LABEL__, {
+    value: label,
+    configurable: false,
+    enumerable: false,
+    writable: false
+  });
+  Object.defineProperty(ctor, __TYPE__, {
+    value: symbol,
+    configurable: false,
+    enumerable: false,
+    writable: false
+  });
+  const parent = Object.getPrototypeOf(ctor);
+  const parentChain = parent && parent[__TYPE_LINEAGE__] ? parent[__TYPE_LINEAGE__] : [];
+  const ctorChain = [...parentChain, symbol];
+  Object.defineProperty(ctor, __TYPE_LINEAGE__, {
+    value: ctorChain,
+    configurable: false,
+    enumerable: false,
+    writable: false
+  });
+  Object.defineProperty(ctor, __TYPE_SET__, {
+    value: new Set(ctorChain),
+    configurable: false,
+    enumerable: false,
+    writable: false
+  });
+  markDecorated(ctor);
+}
+function checkInheritance(ctor, opts) {
+  var _a, _b, _c;
+  const devMarker = (_a = opts == null ? void 0 : opts.devMarker) != null ? _a : OPTIONS.devMarker;
+  const skipLabelInheritanceCheck = (_b = opts == null ? void 0 : opts.skipLabelInheritanceCheck) != null ? _b : OPTIONS.skipLabelInheritanceCheck;
+  const autofillLabels = (_c = opts == null ? void 0 : opts.autofillLabels) != null ? _c : OPTIONS.autofillLabels;
+  if (!devMarker) return;
+  if (!isSigilCtor(ctor)) return;
+  if (isInheritanceChecked(ctor) || skipLabelInheritanceCheck) return;
+  const ctors = [ctor];
+  let ancestor = Object.getPrototypeOf(ctor);
+  while (isSigilCtor(ancestor)) {
+    ctors.push(ancestor);
+    ancestor = Object.getPrototypeOf(ancestor);
+  }
+  const labelOwner = /* @__PURE__ */ new Map();
+  for (let i = ctors.length - 1; i >= 0; i--) {
+    const ctor2 = ctors[i];
+    if (!ctor2) continue;
+    let label = ctor2.SigilLabel;
+    if (labelOwner.has(label)) {
+      if (isDecorated(ctor2) || !autofillLabels) {
+        const ancestorName = labelOwner.get(label);
+        throw new Error(
+          `[Sigil Error] Class "${ctor2.name}" re-uses Sigil label "${label}" from ancestor "${ancestorName}". Each Sigil subclass must use a unique label. Did you forget to use "WithSigil(newLabel)" on the subclass?`
+        );
+      }
+      label = generateRandomLabel();
+      decorateCtor(ctor2, label, opts);
+    }
+    labelOwner.set(label, ctor2.name);
+  }
+  markInheritanceChecked(ctor);
+}
+function verifyLabel(label, opts) {
+  var _a;
+  const labelValidation = (_a = opts == null ? void 0 : opts.labelValidation) != null ? _a : OPTIONS.labelValidation;
+  if (labelValidation) {
+    let valid;
+    if (labelValidation instanceof RegExp) valid = labelValidation.test(label);
+    else valid = labelValidation(label);
+    if (!valid)
+      throw new Error(
+        `[Sigil] Invalid identity label "${label}". Make sure that supplied label matches validation regex or function.`
+      );
+  }
+}
+function generateRandomLabel(length = 16) {
+  let label = generateRandomString(length);
+  const registry = getActiveRegistry();
+  if (registry) while (registry.has(label)) label = generateRandomLabel();
+  return `@Sigil.auto-${label}`;
+}
+function markSigil(ctor) {
+  Object.defineProperty(ctor, __SIGIL__, {
+    value: true,
+    configurable: false,
+    enumerable: false,
+    writable: false
+  });
+}
+function markSigilBase(ctor) {
+  Object.defineProperty(ctor, __SIGIL_BASE__, {
+    value: true,
+    configurable: false,
+    enumerable: false,
+    writable: false
+  });
+}
+function markDecorated(ctor) {
+  Object.defineProperty(ctor, __DECORATED__, {
+    value: true,
+    configurable: false,
+    enumerable: false,
+    writable: false
+  });
+}
+function markInheritanceChecked(ctor) {
+  Object.defineProperty(ctor, __INHERITANCE_CHECKED__, {
+    value: true,
+    configurable: false,
+    enumerable: false,
+    writable: false
+  });
+}
+function isSigilCtor(value) {
+  return typeof value === "function" && value[__SIGIL__] === true;
+}
+function isSigilInstance(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  const ctor = getConstructor(obj);
+  return isSigilCtor(ctor);
+}
+function isSigilBaseCtor(ctor) {
+  return Object.hasOwn(ctor, __SIGIL_BASE__);
+}
+function isSigilBaseInstance(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  const ctor = getConstructor(obj);
+  return isSigilBaseCtor(ctor);
+}
+function isDecorated(ctor) {
+  return Object.hasOwn(ctor, __DECORATED__);
+}
+function isInheritanceChecked(ctor) {
+  return Object.hasOwn(ctor, __INHERITANCE_CHECKED__);
+}
+function getConstructor(obj) {
+  var _a, _b, _c;
+  if (!obj || typeof obj !== "object") return null;
+  return (_c = (_b = obj.constructor) != null ? _b : (_a = Object.getPrototypeOf(obj)) == null ? void 0 : _a.constructor) != null ? _c : null;
+}
+function generateRandomString(length = 16) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+
+// src/core/mixin.ts
+function Sigilify(Base, label, opts) {
+  if (isSigilCtor(Base))
+    throw new Error(`[Sigil Error] 'Sigilify(${label})' already siglified.`);
+  let l;
+  if (label) {
+    verifyLabel(label, opts);
+    l = label;
+  } else l = generateRandomLabel();
+  class Sigilified extends Base {
+    /**
+     * Class-level human-readable label constant for this sigil constructor.
+     */
+    static get SigilLabel() {
+      return this[__LABEL__];
+    }
+    /**
+     * Class-level unique runtime symbol used as the type identifier.
+     *
+     * This symbol is created with `Symbol.for(label)` during decoration so it is
+     * stable across realms that share the same global symbol registry.
+     */
+    static get SigilType() {
+      return this[__TYPE__];
+    }
+    /**
+     * Copy of the linearized sigil type symbol chain for the current constructor.
+     *
+     * Useful for debugging and performing strict lineage comparisons.
+     *
+     * @returns An array of symbols representing parent → child type symbols.
+     */
+    static get SigilTypeLineage() {
+      var _a;
+      return [...(_a = this[__TYPE_LINEAGE__]) != null ? _a : []];
+    }
+    /**
+     * Copy of the sigil type symbol set for the current constructor.
+     *
+     * Useful for quick membership checks (O(1) lookups) and debugging.
+     *
+     * @returns A Readonly Set of symbols that represent the type lineage.
+     */
+    static get SigilTypeSet() {
+      const set = /* @__PURE__ */ new Set();
+      for (const s of this[__TYPE_SET__]) set.add(s);
+      return set;
+    }
+    constructor(...args) {
+      var _a;
+      super(...args);
+      if (Object.getPrototypeOf(this) !== new.target.prototype)
+        Object.setPrototypeOf(this, new.target.prototype);
+      const ctor = getConstructor(this);
+      if (!ctor) {
+        if ((_a = opts == null ? void 0 : opts.devMarker) != null ? _a : OPTIONS.devMarker)
+          throw new Error(
+            `[Sigil Error] 'Sigilify(${label})' instance without constructor`
+          );
+        return;
+      }
+      checkInheritance(ctor);
+    }
+    /**
+     * Runtime predicate indicating whether `obj` is an instance produced by a sigil class.
+     *
+     * @param obj - The value to test.
+     * @returns `true` if `obj` is a sigil instance.
+     */
+    static isSigilified(obj) {
+      return isSigilInstance(obj);
+    }
+    /**
+     * Check whether `other` is (or inherits from) the type represented by the calling constructor.
+     *
+     * Implementation detail:
+     * - Uses the other instance's `__TYPE_SET__` for O(1) membership test.
+     * - O(1) and reliable as long as `OPTIONS.skipLabelInheritanceCheck` is `false`.
+     *
+     * This replaces `instanceof` so that checks remain valid across bundles/realms
+     * and when subclassing.
+     *
+     * @typeParam T - The calling constructor type (narrowing the returned instance type).
+     * @param this - The constructor performing the check.
+     * @param other - The object to test.
+     * @returns `true` if `other` is an instance of this type or a subtype.
+     */
+    static isOfType(other) {
+      if (!isSigilInstance(other)) return false;
+      const otherCtor = getConstructor(other);
+      if (!otherCtor) return false;
+      const otherSet = otherCtor[__TYPE_SET__];
+      return !!otherSet && otherSet.has(this.SigilType);
+    }
+    /**
+     * Strict lineage check: compares the type symbol lineage arrays element-by-element.
+     *
+     * Implementation detail:
+     * - Works in O(n) time where n is the depth of the lineage.
+     * - Reliable when `OPTIONS.skipLabelInheritanceCheck` is `false`.
+     *
+     * @typeParam T - The calling constructor type.
+     * @param this - The constructor performing the check.
+     * @param other - The object to test.
+     * @returns `true` if `other` has an identical lineage up to the length of this constructor's lineage.
+     */
+    static isOfTypeStrict(other) {
+      if (!isSigilInstance(other)) return false;
+      const otherCtor = getConstructor(other);
+      if (!otherCtor) return false;
+      const otherLineage = otherCtor[__TYPE_LINEAGE__];
+      const thisLineage = this[__TYPE_LINEAGE__];
+      return !!otherLineage && thisLineage.every((s, i) => s === otherLineage[i]);
+    }
+    /**
+     * Returns the human-readable sigil label of this instance's constructor.
+     *
+     * @returns The label string (e.g. '@scope/pkg.ClassName') or '@Sigil.unknown' in DEV when constructor is missing.
+     */
+    getSigilLabel() {
+      var _a;
+      const ctor = getConstructor(this);
+      if (!ctor) {
+        if ((_a = opts == null ? void 0 : opts.devMarker) != null ? _a : OPTIONS.devMarker)
+          throw new Error(
+            `[Sigil Error] 'Sigilify(${label})' instance without constructor`
+          );
+        return "@Sigil.unknown";
+      }
+      return ctor.SigilLabel;
+    }
+    /**
+     * Returns the runtime sigil type symbol of this instance's constructor.
+     *
+     * @returns The symbol that identifies this type at runtime.
+     */
+    getSigilType() {
+      var _a;
+      const ctor = getConstructor(this);
+      if (!ctor) {
+        if ((_a = opts == null ? void 0 : opts.devMarker) != null ? _a : OPTIONS.devMarker)
+          throw new Error(
+            `[Sigil Error] 'Sigilify(${label})' instance without constructor`
+          );
+        return /* @__PURE__ */ Symbol.for("@Sigil.unknown");
+      }
+      return ctor.SigilType;
+    }
+    /**
+     * Returns a copy of the sigil type symbol lineage for this instance's constructor.
+     *
+     * @returns readonly array of symbols representing the type lineage.
+     */
+    getSigilTypeLineage() {
+      var _a;
+      const ctor = getConstructor(this);
+      if (!ctor) {
+        if ((_a = opts == null ? void 0 : opts.devMarker) != null ? _a : OPTIONS.devMarker)
+          throw new Error(
+            `[Sigil Error] 'Sigilify(${label})' instance without constructor`
+          );
+        return [/* @__PURE__ */ Symbol.for("@Sigil.unknown")];
+      }
+      return ctor.SigilTypeLineage;
+    }
+    /**
+     * Returns a readonly copy of the sigil type symbol set for this instance's constructor.
+     *
+     * @returns A Readonly Set of symbols representing the type lineage for O(1) membership tests.
+     */
+    getSigilTypeSet() {
+      var _a;
+      const ctor = getConstructor(this);
+      if (!ctor) {
+        if ((_a = opts == null ? void 0 : opts.devMarker) != null ? _a : OPTIONS.devMarker)
+          throw new Error(
+            `[Sigil Error] 'Sigilify(${label})' instance without constructor`
+          );
+        return /* @__PURE__ */ new Set([/* @__PURE__ */ Symbol.for("@Sigil.unknown")]);
+      }
+      return ctor.SigilTypeSet;
+    }
+  }
+  decorateCtor(Sigilified, l);
+  markSigil(Sigilified);
+  markSigilBase(Sigilified);
+  return Sigilified;
+}
+
+// src/core/classes.ts
+var Sigil = Sigilify(class {
+}, "Sigil");
+var SigilError = Sigilify(Error, "SigilError");
+
+// src/core/decorator.ts
+function WithSigil(label, opts) {
+  let l;
+  if (label) {
+    verifyLabel(label, opts);
+    l = label;
+  } else l = generateRandomLabel();
+  return function(value, context) {
+    if (context.kind !== "class") return;
+    if (!isSigilCtor(value))
+      throw new Error(
+        `[Sigil Error] 'WithSigil' decorator accept only Sigil classes but used on class ${value.name}`
+      );
+    decorateCtor(value, l);
+    checkInheritance(value, opts);
+  };
+}
+
+// src/core/enhancers.ts
+function withSigil(Class, label, opts) {
+  var _a;
+  if (!isSigilCtor(Class))
+    throw new Error(
+      `[Sigil Error] 'withSigil' HOF accept only Sigil classes  but used on class ${(_a = Class == null ? void 0 : Class.name) != null ? _a : "unknown"}`
+    );
+  let l;
+  if (label) {
+    verifyLabel(label, opts);
+    l = label;
+  } else l = generateRandomLabel();
+  const ctor = Class;
+  decorateCtor(ctor, l);
+  checkInheritance(ctor, opts);
+  return Class;
+}
+function typed(Class, label, opts) {
+  var _a, _b;
+  const devMarker = (_a = opts == null ? void 0 : opts.devMarker) != null ? _a : OPTIONS.devMarker;
+  if (!isSigilCtor(Class))
+    throw new Error(
+      `[Sigil Error] 'typed' HOF accept only Sigil classes but used on class ${(_b = Class == null ? void 0 : Class.name) != null ? _b : "unknown"}`
+    );
+  if (devMarker && label) {
+    const runtimeLabel = Class.SigilLabel;
+    if (runtimeLabel && runtimeLabel !== label)
+      throw new Error(
+        `[Sigil Error][typed] runtime label "${runtimeLabel}" does not match asserted label "${label}".`
+      );
+  }
+  return Class;
+}
+function withSigilTyped(Class, label, opts) {
+  var _a;
+  if (!isSigilCtor(Class))
+    throw new Error(
+      `[Sigil Error] 'withSigilTyped' HOF accept only Sigil classes but used on class ${(_a = Class == null ? void 0 : Class.name) != null ? _a : "unknown"}`
+    );
+  let l;
+  if (label) {
+    verifyLabel(label, opts);
+    l = label;
+  } else l = generateRandomLabel();
+  const ctor = Class;
+  decorateCtor(ctor, l);
+  checkInheritance(ctor, opts);
+  return Class;
+}
+
+export { DEFAULT_LABEL_REGEX, REGISTRY, Sigil, SigilError, SigilRegistry, Sigilify, WithSigil, getActiveRegistry, isDecorated, isInheritanceChecked, isSigilBaseCtor, isSigilBaseInstance, isSigilCtor, isSigilInstance, typed, updateOptions, withSigil, withSigilTyped };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map