@servlyadmin/runtime-core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1519 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_CACHE_CONFIG: () => DEFAULT_CACHE_CONFIG,
+  DEFAULT_RETRY_CONFIG: () => DEFAULT_RETRY_CONFIG,
+  applyStyles: () => applyStyles,
+  buildClassName: () => buildClassName,
+  buildElementStyles: () => buildElementStyles,
+  bumpVersion: () => bumpVersion,
+  camelToKebab: () => camelToKebab,
+  clearAllCaches: () => clearAllCaches,
+  clearLocalStorageCache: () => clearLocalStorageCache,
+  clearMemoryCache: () => clearMemoryCache,
+  clearStyles: () => clearStyles,
+  compareVersions: () => compareVersions,
+  extractBindingKeys: () => extractBindingKeys,
+  fetchComponent: () => fetchComponent,
+  formatStyleValue: () => formatStyleValue,
+  formatVersion: () => formatVersion,
+  generateTestCases: () => generateTestCases,
+  getCacheKey: () => getCacheKey,
+  getFromCache: () => getFromCache,
+  getMemoryCacheSize: () => getMemoryCacheSize,
+  getRegistryUrl: () => getRegistryUrl,
+  hasTemplateSyntax: () => hasTemplateSyntax,
+  invalidateCache: () => invalidateCache,
+  isComponentAvailable: () => isComponentAvailable,
+  isValidSpecifier: () => isValidSpecifier,
+  parseVersion: () => parseVersion,
+  prefetchComponents: () => prefetchComponents,
+  processStyles: () => processStyles,
+  render: () => render,
+  resolveBindingPath: () => resolveBindingPath,
+  resolveTemplate: () => resolveTemplate,
+  resolveTemplateValue: () => resolveTemplateValue,
+  resolveTemplatesDeep: () => resolveTemplatesDeep,
+  resolveVersion: () => resolveVersion,
+  runAllTests: () => runAllTests,
+  runTestCase: () => runTestCase,
+  satisfiesVersion: () => satisfiesVersion,
+  setInCache: () => setInCache,
+  setRegistryUrl: () => setRegistryUrl,
+  updateStyles: () => updateStyles,
+  validateAssertion: () => validateAssertion,
+  validateProps: () => validateProps
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/bindings.ts
+var BINDING_SOURCES = [
+  "props",
+  "state",
+  "appState",
+  "context",
+  "input",
+  "currentItem",
+  "localStore",
+  "config",
+  "element",
+  "self",
+  "params",
+  "query"
+];
+var TEMPLATE_REGEX = /\{\{([^}]+)\}\}/g;
+function hasTemplateSyntax(value) {
+  return typeof value === "string" && value.includes("{{") && value.includes("}}");
+}
+function resolveBindingPath(path, context) {
+  const trimmed = path.trim();
+  const parts = trimmed.split(".");
+  if (parts.length === 0) {
+    return void 0;
+  }
+  const prefix = parts[0].toLowerCase();
+  let source;
+  let startIndex = 0;
+  if (prefix === "props" || prefix === "input") {
+    source = context.props;
+    startIndex = 1;
+  } else if (prefix === "state" || prefix === "appstate") {
+    source = context.state;
+    startIndex = 1;
+  } else if (prefix === "context") {
+    source = context.context;
+    startIndex = 1;
+  } else if (BINDING_SOURCES.includes(prefix)) {
+    source = context.props;
+    startIndex = 1;
+  } else {
+    source = context.props;
+    startIndex = 0;
+  }
+  if (!source) {
+    return void 0;
+  }
+  let value = source;
+  for (let i = startIndex; i < parts.length; i++) {
+    if (value === null || value === void 0) {
+      return void 0;
+    }
+    value = value[parts[i]];
+  }
+  return value;
+}
+function resolveExpression(expression, context) {
+  const trimmed = expression.trim();
+  const defaultMatch = trimmed.match(/^(.+?)\|\|(.+)$/);
+  if (defaultMatch) {
+    const mainValue = resolveExpression(defaultMatch[1].trim(), context);
+    if (mainValue !== void 0 && mainValue !== null && mainValue !== "") {
+      return mainValue;
+    }
+    const defaultVal = defaultMatch[2].trim();
+    if (defaultVal.startsWith('"') && defaultVal.endsWith('"') || defaultVal.startsWith("'") && defaultVal.endsWith("'")) {
+      return defaultVal.slice(1, -1);
+    }
+    if (!isNaN(Number(defaultVal))) {
+      return Number(defaultVal);
+    }
+    if (defaultVal === "true") return true;
+    if (defaultVal === "false") return false;
+    return resolveExpression(defaultVal, context);
+  }
+  const ternaryMatch = trimmed.match(/^(.+?)\s*\?\s*(.+?)\s*:\s*(.+)$/);
+  if (ternaryMatch) {
+    const condition = resolveExpression(ternaryMatch[1].trim(), context);
+    if (condition) {
+      return resolveTernaryValue(ternaryMatch[2].trim(), context);
+    }
+    return resolveTernaryValue(ternaryMatch[3].trim(), context);
+  }
+  if (trimmed.includes("&&")) {
+    const parts = trimmed.split("&&");
+    for (const part of parts) {
+      const value = resolveExpression(part.trim(), context);
+      if (!value) return value;
+    }
+    return resolveExpression(parts[parts.length - 1].trim(), context);
+  }
+  return resolveBindingPath(trimmed, context);
+}
+function resolveTernaryValue(value, context) {
+  if (value.startsWith("'") && value.endsWith("'") || value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1);
+  }
+  if (!isNaN(Number(value))) {
+    return Number(value);
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (value === "undefined") return void 0;
+  return resolveExpression(value, context);
+}
+function resolveTemplate(template, context) {
+  if (!template || typeof template !== "string") {
+    return template;
+  }
+  if (!hasTemplateSyntax(template)) {
+    return template;
+  }
+  const singleMatch = template.match(/^\{\{([^}]+)\}\}$/);
+  if (singleMatch) {
+    const value = resolveExpression(singleMatch[1], context);
+    if (value === void 0 || value === null) {
+      return "";
+    }
+    return String(value);
+  }
+  return template.replace(TEMPLATE_REGEX, (match, expression) => {
+    const value = resolveExpression(expression, context);
+    if (value === void 0 || value === null) {
+      return "";
+    }
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  });
+}
+function resolveTemplateValue(template, context) {
+  if (!template || typeof template !== "string") {
+    return template;
+  }
+  if (!hasTemplateSyntax(template)) {
+    return template;
+  }
+  const singleMatch = template.match(/^\{\{([^}]+)\}\}$/);
+  if (singleMatch) {
+    return resolveExpression(singleMatch[1], context);
+  }
+  return resolveTemplate(template, context);
+}
+function isPlainObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function resolveTemplatesDeep(input, context) {
+  if (typeof input === "string") {
+    return resolveTemplateValue(input, context);
+  }
+  if (Array.isArray(input)) {
+    let changed = false;
+    const result = input.map((item) => {
+      const resolved = resolveTemplatesDeep(item, context);
+      if (resolved !== item) {
+        changed = true;
+      }
+      return resolved;
+    });
+    return changed ? result : input;
+  }
+  if (input && typeof input === "object") {
+    if (!isPlainObject(input)) {
+      return input;
+    }
+    let mutable = null;
+    const original = input;
+    for (const key of Object.keys(original)) {
+      const current = original[key];
+      const resolved = resolveTemplatesDeep(current, context);
+      if (resolved !== current) {
+        const target = mutable ?? (mutable = { ...original });
+        target[key] = resolved;
+      }
+    }
+    return mutable ?? input;
+  }
+  return input;
+}
+function extractBindingKeys(template) {
+  if (!template || typeof template !== "string") {
+    return [];
+  }
+  const keys = /* @__PURE__ */ new Set();
+  const matches = template.matchAll(TEMPLATE_REGEX);
+  for (const match of matches) {
+    const expression = match[1].trim();
+    const pathMatch = expression.match(/^([a-zA-Z_][a-zA-Z0-9_.]*)/);
+    if (pathMatch) {
+      const parts = pathMatch[1].split(".");
+      if (parts.length > 1 && BINDING_SOURCES.includes(parts[0].toLowerCase())) {
+        keys.add(parts[parts.length - 1]);
+      } else {
+        keys.add(parts[0]);
+      }
+    }
+  }
+  return Array.from(keys);
+}
+
+// src/styles.ts
+var UNITLESS_PROPERTIES = /* @__PURE__ */ new Set([
+  "animationIterationCount",
+  "borderImageOutset",
+  "borderImageSlice",
+  "borderImageWidth",
+  "boxFlex",
+  "boxFlexGroup",
+  "boxOrdinalGroup",
+  "columnCount",
+  "columns",
+  "flex",
+  "flexGrow",
+  "flexPositive",
+  "flexShrink",
+  "flexNegative",
+  "flexOrder",
+  "gridRow",
+  "gridRowEnd",
+  "gridRowSpan",
+  "gridRowStart",
+  "gridColumn",
+  "gridColumnEnd",
+  "gridColumnSpan",
+  "gridColumnStart",
+  "fontWeight",
+  "lineClamp",
+  "lineHeight",
+  "opacity",
+  "order",
+  "orphans",
+  "tabSize",
+  "widows",
+  "zIndex",
+  "zoom",
+  "fillOpacity",
+  "floodOpacity",
+  "stopOpacity",
+  "strokeDasharray",
+  "strokeDashoffset",
+  "strokeMiterlimit",
+  "strokeOpacity",
+  "strokeWidth"
+]);
+function camelToKebab(str) {
+  return str.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+function needsUnits(property) {
+  if (property.startsWith("--")) {
+    return false;
+  }
+  return !UNITLESS_PROPERTIES.has(property);
+}
+function formatStyleValue(property, value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "number" && needsUnits(property)) {
+    return `${value}px`;
+  }
+  return String(value);
+}
+function processStyles(style, context) {
+  if (!style || Object.keys(style).length === 0) {
+    return {};
+  }
+  const processed = {};
+  for (const [key, value] of Object.entries(style)) {
+    if (value === void 0 || value === null || value === "") {
+      continue;
+    }
+    let resolvedValue = value;
+    if (typeof value === "string" && hasTemplateSyntax(value)) {
+      resolvedValue = resolveTemplate(value, context);
+    }
+    if (resolvedValue === void 0 || resolvedValue === null || resolvedValue === "") {
+      continue;
+    }
+    const formattedValue = formatStyleValue(key, resolvedValue);
+    if (formattedValue) {
+      processed[key] = formattedValue;
+    }
+  }
+  return processed;
+}
+function applyStyles(element, styles) {
+  for (const [property, value] of Object.entries(styles)) {
+    if (property.startsWith("--")) {
+      element.style.setProperty(property, value);
+    } else {
+      element.style[property] = value;
+    }
+  }
+}
+function buildElementStyles(element, context) {
+  const config = element.configuration || {};
+  const combined = {};
+  if (element.style) {
+    Object.assign(combined, element.style);
+  }
+  if (config.style) {
+    Object.assign(combined, config.style);
+  }
+  if (config.cssVariables) {
+    Object.assign(combined, config.cssVariables);
+  }
+  return processStyles(combined, context);
+}
+function buildClassName(element, context) {
+  const config = element.configuration || {};
+  const classes = [];
+  if (element.className) {
+    classes.push(element.className);
+  }
+  if (config.className) {
+    const resolved = hasTemplateSyntax(config.className) ? resolveTemplate(config.className, context) : config.className;
+    if (resolved) classes.push(resolved);
+  }
+  if (config.classNames) {
+    const resolved = hasTemplateSyntax(config.classNames) ? resolveTemplate(config.classNames, context) : config.classNames;
+    if (resolved) classes.push(resolved);
+  }
+  if (config.dynamicClassName) {
+    const resolved = resolveTemplate(config.dynamicClassName, context);
+    if (resolved) classes.push(resolved);
+  }
+  return classes.filter(Boolean).join(" ").trim();
+}
+function clearStyles(element) {
+  element.removeAttribute("style");
+}
+function updateStyles(element, oldStyles, newStyles) {
+  for (const property of Object.keys(oldStyles)) {
+    if (!(property in newStyles)) {
+      if (property.startsWith("--")) {
+        element.style.removeProperty(property);
+      } else {
+        element.style[property] = "";
+      }
+    }
+  }
+  for (const [property, value] of Object.entries(newStyles)) {
+    if (oldStyles[property] !== value) {
+      if (property.startsWith("--")) {
+        element.style.setProperty(property, value);
+      } else {
+        element.style[property] = value;
+      }
+    }
+  }
+}
+
+// src/renderer.ts
+var COMPONENT_TO_TAG = {
+  container: "div",
+  text: "span",
+  button: "button",
+  input: "input",
+  image: "img",
+  link: "a",
+  form: "form",
+  label: "label",
+  textarea: "textarea",
+  select: "select",
+  option: "option",
+  list: "ul",
+  listItem: "li",
+  heading: "h1",
+  paragraph: "p",
+  section: "section",
+  article: "article",
+  header: "header",
+  footer: "footer",
+  nav: "nav",
+  aside: "aside",
+  main: "main",
+  span: "span",
+  div: "div"
+};
+var SELF_CLOSING_TAGS = /* @__PURE__ */ new Set([
+  "input",
+  "img",
+  "br",
+  "hr",
+  "area",
+  "base",
+  "col",
+  "embed",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function getElementTag(element) {
+  const config = element.configuration;
+  if (config?.tag) {
+    return config.tag;
+  }
+  if (element.componentId && COMPONENT_TO_TAG[element.componentId]) {
+    return COMPONENT_TO_TAG[element.componentId];
+  }
+  if (element.isGroup) {
+    return "div";
+  }
+  return "div";
+}
+function isSelfClosing(tag) {
+  return SELF_CLOSING_TAGS.has(tag.toLowerCase());
+}
+function buildTree(elements) {
+  const tree = /* @__PURE__ */ new Map();
+  for (const element of elements) {
+    const parentId = element.parent || null;
+    if (!tree.has(parentId)) {
+      tree.set(parentId, []);
+    }
+    tree.get(parentId).push(element);
+  }
+  return tree;
+}
+function getTextContent(element, context) {
+  const config = element.configuration;
+  if (config?.dynamicText) {
+    return resolveTemplate(config.dynamicText, context);
+  }
+  if (config?.text) {
+    if (hasTemplateSyntax(config.text)) {
+      return resolveTemplate(config.text, context);
+    }
+    return config.text;
+  }
+  return "";
+}
+function applyAttributes(domElement, element, context) {
+  const config = element.configuration || {};
+  const attributeMap = [
+    { key: "id", attr: "id" },
+    { key: "src", dynamicKey: "dynamicSrc", attr: "src" },
+    { key: "alt", attr: "alt" },
+    { key: "href", dynamicKey: "dynamicHref", attr: "href" },
+    { key: "target", attr: "target" },
+    { key: "placeholder", attr: "placeholder" },
+    { key: "type", attr: "type" },
+    { key: "name", attr: "name" },
+    { key: "value", dynamicKey: "dynamicValue", attr: "value" }
+  ];
+  for (const { key, dynamicKey, attr } of attributeMap) {
+    const dynamicValue = dynamicKey ? config[dynamicKey] : void 0;
+    if (dynamicValue !== void 0 && dynamicValue !== null && dynamicValue !== "") {
+      const resolved = resolveTemplate(String(dynamicValue), context);
+      if (resolved) {
+        domElement.setAttribute(attr, resolved);
+      }
+      continue;
+    }
+    const staticValue = config[key];
+    if (staticValue !== void 0 && staticValue !== null && staticValue !== "") {
+      const resolved = hasTemplateSyntax(String(staticValue)) ? resolveTemplate(String(staticValue), context) : String(staticValue);
+      if (resolved) {
+        domElement.setAttribute(attr, resolved);
+      }
+    }
+  }
+  if (config.disabled) domElement.setAttribute("disabled", "");
+  if (config.required) domElement.setAttribute("required", "");
+  if (config.readOnly) domElement.setAttribute("readonly", "");
+  for (const [key, value] of Object.entries(config)) {
+    if (key.startsWith("data-") && value !== void 0) {
+      const resolved = hasTemplateSyntax(String(value)) ? resolveTemplate(String(value), context) : String(value);
+      domElement.setAttribute(key, resolved);
+    }
+  }
+  for (const [key, value] of Object.entries(config)) {
+    if (key.startsWith("aria-") && value !== void 0) {
+      const resolved = hasTemplateSyntax(String(value)) ? resolveTemplate(String(value), context) : String(value);
+      domElement.setAttribute(key, resolved);
+    }
+  }
+}
+function attachEventHandlers(domElement, elementId, eventHandlers, elementState) {
+  if (!eventHandlers || !eventHandlers[elementId]) {
+    return;
+  }
+  const handlers = eventHandlers[elementId];
+  for (const [eventName, handler] of Object.entries(handlers)) {
+    const domEventName = eventName.replace(/^on/, "").toLowerCase();
+    elementState.eventListeners.set(domEventName, handler);
+    domElement.addEventListener(domEventName, handler);
+  }
+}
+function detachEventHandlers(elementState) {
+  for (const [eventName, handler] of elementState.eventListeners) {
+    elementState.domElement.removeEventListener(eventName, handler);
+  }
+  elementState.eventListeners.clear();
+}
+function createElement(element, context, eventHandlers) {
+  const tag = getElementTag(element);
+  const domElement = document.createElement(tag);
+  domElement.setAttribute("data-servly-id", element.i);
+  const styles = buildElementStyles(element, context);
+  applyStyles(domElement, styles);
+  const className = buildClassName(element, context);
+  if (className) {
+    domElement.className = className;
+  }
+  applyAttributes(domElement, element, context);
+  let textContent = "";
+  if (element.componentId === "text" || !isSelfClosing(tag)) {
+    textContent = getTextContent(element, context);
+    if (textContent && !element.children?.length) {
+      domElement.textContent = textContent;
+    }
+  }
+  const elementState = {
+    element,
+    domElement,
+    styles,
+    className,
+    textContent,
+    eventListeners: /* @__PURE__ */ new Map()
+  };
+  attachEventHandlers(domElement, element.i, eventHandlers, elementState);
+  return elementState;
+}
+function renderElement(element, tree, context, eventHandlers, elementStates) {
+  const elementState = createElement(element, context, eventHandlers);
+  elementStates.set(element.i, elementState);
+  const children = tree.get(element.i) || [];
+  for (const child of children) {
+    const childElement = renderElement(child, tree, context, eventHandlers, elementStates);
+    elementState.domElement.appendChild(childElement);
+  }
+  return elementState.domElement;
+}
+function render(options) {
+  const { container, elements, context, eventHandlers } = options;
+  const tree = buildTree(elements);
+  const rootElements = elements.filter((el) => !el.parent || el.parent === null);
+  const state = {
+    container,
+    elements,
+    context,
+    eventHandlers,
+    elementStates: /* @__PURE__ */ new Map(),
+    rootElement: null
+  };
+  container.innerHTML = "";
+  if (rootElements.length === 0) {
+    return {
+      rootElement: null,
+      update: (newContext) => update(state, newContext),
+      destroy: () => destroy(state)
+    };
+  }
+  if (rootElements.length === 1) {
+    state.rootElement = renderElement(
+      rootElements[0],
+      tree,
+      context,
+      eventHandlers,
+      state.elementStates
+    );
+    container.appendChild(state.rootElement);
+  } else {
+    const wrapper = document.createElement("div");
+    wrapper.setAttribute("data-servly-wrapper", "true");
+    for (const root of rootElements) {
+      const rootElement = renderElement(root, tree, context, eventHandlers, state.elementStates);
+      wrapper.appendChild(rootElement);
+    }
+    state.rootElement = wrapper;
+    container.appendChild(wrapper);
+  }
+  return {
+    rootElement: state.rootElement,
+    update: (newContext) => update(state, newContext),
+    destroy: () => destroy(state)
+  };
+}
+function update(state, newContext) {
+  state.context = newContext;
+  for (const [elementId, elementState] of state.elementStates) {
+    const { element, domElement } = elementState;
+    const newStyles = buildElementStyles(element, newContext);
+    updateStyles(domElement, elementState.styles, newStyles);
+    elementState.styles = newStyles;
+    const newClassName = buildClassName(element, newContext);
+    if (newClassName !== elementState.className) {
+      domElement.className = newClassName;
+      elementState.className = newClassName;
+    }
+    const newTextContent = getTextContent(element, newContext);
+    if (newTextContent !== elementState.textContent) {
+      const children = state.elements.filter((el) => el.parent === elementId);
+      if (children.length === 0) {
+        domElement.textContent = newTextContent;
+      }
+      elementState.textContent = newTextContent;
+    }
+    applyAttributes(domElement, element, newContext);
+  }
+}
+function destroy(state) {
+  for (const elementState of state.elementStates.values()) {
+    detachEventHandlers(elementState);
+  }
+  state.elementStates.clear();
+  if (state.rootElement && state.rootElement.parentNode) {
+    state.rootElement.parentNode.removeChild(state.rootElement);
+  }
+  state.rootElement = null;
+}
+
+// src/cache.ts
+var DEFAULT_CACHE_CONFIG = {
+  maxEntries: 50,
+  ttl: 5 * 60 * 1e3,
+  // 5 minutes
+  storageKeyPrefix: "servly_component_"
+};
+var memoryCache = /* @__PURE__ */ new Map();
+function getCacheKey(id, version = "latest") {
+  return `${id}@${version}`;
+}
+function getFromMemoryCache(id, version = "latest", config = DEFAULT_CACHE_CONFIG) {
+  const key = getCacheKey(id, version);
+  const entry = memoryCache.get(key);
+  if (!entry) {
+    return null;
+  }
+  const ttl = config.ttl ?? DEFAULT_CACHE_CONFIG.ttl;
+  if (Date.now() - entry.timestamp > ttl) {
+    memoryCache.delete(key);
+    return null;
+  }
+  entry.accessCount++;
+  entry.lastAccessed = Date.now();
+  return entry.data;
+}
+function setInMemoryCache(id, version, data, config = DEFAULT_CACHE_CONFIG) {
+  const key = getCacheKey(id, version);
+  const maxEntries = config.maxEntries ?? DEFAULT_CACHE_CONFIG.maxEntries;
+  if (memoryCache.size >= maxEntries && !memoryCache.has(key)) {
+    evictLRUFromMemory();
+  }
+  memoryCache.set(key, {
+    data,
+    timestamp: Date.now(),
+    version,
+    accessCount: 1,
+    lastAccessed: Date.now()
+  });
+}
+function evictLRUFromMemory() {
+  let lruKey = null;
+  let lruTime = Infinity;
+  for (const [key, entry] of memoryCache.entries()) {
+    if (entry.lastAccessed < lruTime) {
+      lruTime = entry.lastAccessed;
+      lruKey = key;
+    }
+  }
+  if (lruKey) {
+    memoryCache.delete(lruKey);
+  }
+}
+function clearMemoryCache() {
+  memoryCache.clear();
+}
+function getMemoryCacheSize() {
+  return memoryCache.size;
+}
+function isLocalStorageAvailable() {
+  try {
+    const test = "__servly_test__";
+    localStorage.setItem(test, test);
+    localStorage.removeItem(test);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getStorageKey(id, version, config) {
+  const prefix = config.storageKeyPrefix ?? DEFAULT_CACHE_CONFIG.storageKeyPrefix;
+  return `${prefix}${getCacheKey(id, version)}`;
+}
+function getFromLocalStorage(id, version = "latest", config = DEFAULT_CACHE_CONFIG) {
+  if (!isLocalStorageAvailable()) {
+    return null;
+  }
+  try {
+    const key = getStorageKey(id, version, config);
+    const stored = localStorage.getItem(key);
+    if (!stored) {
+      return null;
+    }
+    const entry = JSON.parse(stored);
+    const ttl = config.ttl ?? DEFAULT_CACHE_CONFIG.ttl;
+    if (Date.now() - entry.timestamp > ttl) {
+      localStorage.removeItem(key);
+      return null;
+    }
+    entry.accessCount++;
+    entry.lastAccessed = Date.now();
+    localStorage.setItem(key, JSON.stringify(entry));
+    return entry.data;
+  } catch (error) {
+    console.warn("Error reading from localStorage cache:", error);
+    return null;
+  }
+}
+function setInLocalStorage(id, version, data, config = DEFAULT_CACHE_CONFIG) {
+  if (!isLocalStorageAvailable()) {
+    return;
+  }
+  try {
+    const key = getStorageKey(id, version, config);
+    const maxEntries = config.maxEntries ?? DEFAULT_CACHE_CONFIG.maxEntries;
+    const currentCount = getLocalStorageCacheCount(config);
+    if (currentCount >= maxEntries) {
+      evictLRUFromLocalStorage(config);
+    }
+    const entry = {
+      data,
+      timestamp: Date.now(),
+      version,
+      accessCount: 1,
+      lastAccessed: Date.now()
+    };
+    localStorage.setItem(key, JSON.stringify(entry));
+  } catch (error) {
+    console.warn("Error writing to localStorage cache:", error);
+    if (error instanceof DOMException && error.name === "QuotaExceededError") {
+      evictLRUFromLocalStorage(config);
+      try {
+        const key = getStorageKey(id, version, config);
+        const entry = {
+          data,
+          timestamp: Date.now(),
+          version,
+          accessCount: 1,
+          lastAccessed: Date.now()
+        };
+        localStorage.setItem(key, JSON.stringify(entry));
+      } catch {
+      }
+    }
+  }
+}
+function getLocalStorageCacheCount(config) {
+  const prefix = config.storageKeyPrefix ?? DEFAULT_CACHE_CONFIG.storageKeyPrefix;
+  let count = 0;
+  for (let i = 0; i < localStorage.length; i++) {
+    const key = localStorage.key(i);
+    if (key?.startsWith(prefix)) {
+      count++;
+    }
+  }
+  return count;
+}
+function evictLRUFromLocalStorage(config) {
+  const prefix = config.storageKeyPrefix ?? DEFAULT_CACHE_CONFIG.storageKeyPrefix;
+  let lruKey = null;
+  let lruTime = Infinity;
+  for (let i = 0; i < localStorage.length; i++) {
+    const key = localStorage.key(i);
+    if (!key?.startsWith(prefix)) continue;
+    try {
+      const stored = localStorage.getItem(key);
+      if (stored) {
+        const entry = JSON.parse(stored);
+        if (entry.lastAccessed < lruTime) {
+          lruTime = entry.lastAccessed;
+          lruKey = key;
+        }
+      }
+    } catch {
+      if (key) localStorage.removeItem(key);
+    }
+  }
+  if (lruKey) {
+    localStorage.removeItem(lruKey);
+  }
+}
+function clearLocalStorageCache(config = DEFAULT_CACHE_CONFIG) {
+  if (!isLocalStorageAvailable()) {
+    return;
+  }
+  const prefix = config.storageKeyPrefix ?? DEFAULT_CACHE_CONFIG.storageKeyPrefix;
+  const keysToRemove = [];
+  for (let i = 0; i < localStorage.length; i++) {
+    const key = localStorage.key(i);
+    if (key?.startsWith(prefix)) {
+      keysToRemove.push(key);
+    }
+  }
+  keysToRemove.forEach((key) => localStorage.removeItem(key));
+}
+function getFromCache(id, version = "latest", strategy = "memory", config = DEFAULT_CACHE_CONFIG) {
+  if (strategy === "none") {
+    return null;
+  }
+  const memoryResult = getFromMemoryCache(id, version, config);
+  if (memoryResult) {
+    return memoryResult;
+  }
+  if (strategy === "localStorage") {
+    const localResult = getFromLocalStorage(id, version, config);
+    if (localResult) {
+      setInMemoryCache(id, version, localResult, config);
+      return localResult;
+    }
+  }
+  return null;
+}
+function setInCache(id, version, data, strategy = "memory", config = DEFAULT_CACHE_CONFIG) {
+  if (strategy === "none") {
+    return;
+  }
+  setInMemoryCache(id, version, data, config);
+  if (strategy === "localStorage") {
+    setInLocalStorage(id, version, data, config);
+  }
+}
+function clearAllCaches(config = DEFAULT_CACHE_CONFIG) {
+  clearMemoryCache();
+  clearLocalStorageCache(config);
+}
+function invalidateCache(id, version, config = DEFAULT_CACHE_CONFIG) {
+  if (version) {
+    const key = getCacheKey(id, version);
+    memoryCache.delete(key);
+    if (isLocalStorageAvailable()) {
+      const storageKey = getStorageKey(id, version, config);
+      localStorage.removeItem(storageKey);
+    }
+  } else {
+    const prefix = `${id}@`;
+    for (const key of memoryCache.keys()) {
+      if (key.startsWith(prefix)) {
+        memoryCache.delete(key);
+      }
+    }
+    if (isLocalStorageAvailable()) {
+      const storagePrefix = (config.storageKeyPrefix ?? DEFAULT_CACHE_CONFIG.storageKeyPrefix) + prefix;
+      const keysToRemove = [];
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key?.startsWith(storagePrefix)) {
+          keysToRemove.push(key);
+        }
+      }
+      keysToRemove.forEach((key) => localStorage.removeItem(key));
+    }
+  }
+}
+
+// src/version.ts
+function parseVersion(version) {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!match) return null;
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10)
+  };
+}
+function compareVersions(a, b) {
+  const parsedA = parseVersion(a);
+  const parsedB = parseVersion(b);
+  if (!parsedA || !parsedB) return 0;
+  if (parsedA.major !== parsedB.major) {
+    return parsedA.major > parsedB.major ? 1 : -1;
+  }
+  if (parsedA.minor !== parsedB.minor) {
+    return parsedA.minor > parsedB.minor ? 1 : -1;
+  }
+  if (parsedA.patch !== parsedB.patch) {
+    return parsedA.patch > parsedB.patch ? 1 : -1;
+  }
+  return 0;
+}
+function satisfiesVersion(version, specifier) {
+  if (specifier === "latest" || specifier === "*") {
+    return true;
+  }
+  const parsed = parseVersion(version);
+  if (!parsed) return false;
+  if (/^\d+\.\d+\.\d+$/.test(specifier)) {
+    return version === specifier;
+  }
+  if (specifier.startsWith("^")) {
+    const specParsed = parseVersion(specifier.slice(1));
+    if (!specParsed) return false;
+    if (parsed.major !== specParsed.major) return false;
+    if (parsed.major === 0) {
+      return parsed.minor === specParsed.minor && parsed.patch >= specParsed.patch;
+    }
+    return compareVersions(version, specifier.slice(1)) >= 0;
+  }
+  if (specifier.startsWith("~")) {
+    const specParsed = parseVersion(specifier.slice(1));
+    if (!specParsed) return false;
+    return parsed.major === specParsed.major && parsed.minor === specParsed.minor && parsed.patch >= specParsed.patch;
+  }
+  if (specifier.startsWith(">=")) {
+    return compareVersions(version, specifier.slice(2)) >= 0;
+  }
+  if (specifier.startsWith(">")) {
+    return compareVersions(version, specifier.slice(1)) > 0;
+  }
+  if (specifier.startsWith("<=")) {
+    return compareVersions(version, specifier.slice(2)) <= 0;
+  }
+  if (specifier.startsWith("<")) {
+    return compareVersions(version, specifier.slice(1)) < 0;
+  }
+  return false;
+}
+function resolveVersion(versions, specifier = "latest") {
+  if (versions.length === 0) {
+    return null;
+  }
+  const sorted = [...versions].sort((a, b) => compareVersions(b, a));
+  if (specifier === "latest" || specifier === "*") {
+    return sorted[0];
+  }
+  if (/^\d+\.\d+\.\d+$/.test(specifier)) {
+    return versions.includes(specifier) ? specifier : null;
+  }
+  for (const version of sorted) {
+    if (satisfiesVersion(version, specifier)) {
+      return version;
+    }
+  }
+  return null;
+}
+function bumpVersion(currentVersion, bumpType) {
+  const parsed = parseVersion(currentVersion);
+  if (!parsed) return "1.0.0";
+  switch (bumpType) {
+    case "major":
+      return `${parsed.major + 1}.0.0`;
+    case "minor":
+      return `${parsed.major}.${parsed.minor + 1}.0`;
+    case "patch":
+      return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+    default:
+      return currentVersion;
+  }
+}
+function isValidSpecifier(specifier) {
+  if (specifier === "latest" || specifier === "*") {
+    return true;
+  }
+  if (/^\d+\.\d+\.\d+$/.test(specifier)) {
+    return true;
+  }
+  if (/^[\^~><]=?\d+\.\d+\.\d+$/.test(specifier)) {
+    return true;
+  }
+  return false;
+}
+function formatVersion(version) {
+  const parsed = parseVersion(version);
+  if (!parsed) return version;
+  return `v${parsed.major}.${parsed.minor}.${parsed.patch}`;
+}
+
+// src/fetcher.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  initialDelay: 1e3,
+  maxDelay: 1e4,
+  backoffMultiplier: 2
+};
+var registryBaseUrl = "/api/components";
+function setRegistryUrl(url) {
+  registryBaseUrl = url;
+}
+function getRegistryUrl() {
+  if (typeof window !== "undefined") {
+    const envUrl = window.__SERVLY_REGISTRY_URL__;
+    if (envUrl) return envUrl;
+  }
+  if (typeof process !== "undefined" && process.env?.SERVLY_REGISTRY_URL) {
+    return process.env.SERVLY_REGISTRY_URL;
+  }
+  return registryBaseUrl;
+}
+function calculateBackoffDelay(retryCount, config) {
+  const delay = config.initialDelay * Math.pow(config.backoffMultiplier, retryCount);
+  return Math.min(delay, config.maxDelay);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function resolveVersionFromApi(id, specifier, apiKey) {
+  if (/^\d+\.\d+\.\d+$/.test(specifier)) {
+    return specifier;
+  }
+  const baseUrl = getRegistryUrl();
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  try {
+    const response = await fetch(
+      `${baseUrl}/${id}/versions?specifier=${encodeURIComponent(specifier)}`,
+      { headers }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to resolve version: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.success && data.data?.resolvedVersion) {
+      return data.data.resolvedVersion;
+    }
+    if (data.data?.versions) {
+      const resolved = resolveVersion(data.data.versions, specifier);
+      if (resolved) return resolved;
+    }
+    throw new Error(data.error || "Failed to resolve version");
+  } catch (error) {
+    console.warn(`Failed to resolve version for ${id}@${specifier}:`, error);
+    return "latest";
+  }
+}
+async function fetchFromRegistry(id, version, apiKey) {
+  const baseUrl = getRegistryUrl();
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  const url = version && version !== "latest" ? `${baseUrl}/${id}/versions/${version}` : `${baseUrl}/${id}`;
+  const response = await fetch(url, { headers });
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error(`Component not found: ${id}@${version}`);
+    }
+    if (response.status === 401) {
+      throw new Error("Unauthorized: Invalid or missing API key");
+    }
+    if (response.status === 403) {
+      throw new Error("Forbidden: Access denied to this component");
+    }
+    throw new Error(`Failed to fetch component: ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (!data.success || !data.data) {
+    throw new Error(data.error || "Failed to fetch component data");
+  }
+  return data.data;
+}
+async function fetchComponent(id, options = {}) {
+  const {
+    version = "latest",
+    apiKey,
+    cacheStrategy = "memory",
+    cacheConfig = DEFAULT_CACHE_CONFIG,
+    retryConfig = {},
+    forceRefresh = false,
+    signal
+  } = options;
+  const fullRetryConfig = {
+    ...DEFAULT_RETRY_CONFIG,
+    ...retryConfig
+  };
+  if (!forceRefresh) {
+    const cached = getFromCache(id, version, cacheStrategy, cacheConfig);
+    if (cached) {
+      return {
+        data: cached,
+        fromCache: true,
+        version: cached.version
+      };
+    }
+  }
+  const resolvedVersion = await resolveVersionFromApi(id, version, apiKey);
+  if (!forceRefresh && resolvedVersion !== version) {
+    const cached = getFromCache(id, resolvedVersion, cacheStrategy, cacheConfig);
+    if (cached) {
+      return {
+        data: cached,
+        fromCache: true,
+        version: resolvedVersion
+      };
+    }
+  }
+  let lastError = null;
+  for (let attempt = 0; attempt <= fullRetryConfig.maxRetries; attempt++) {
+    if (signal?.aborted) {
+      throw new Error("Fetch aborted");
+    }
+    try {
+      const data = await fetchFromRegistry(id, resolvedVersion, apiKey);
+      setInCache(id, resolvedVersion, data, cacheStrategy, cacheConfig);
+      if (version !== resolvedVersion) {
+        setInCache(id, version, data, cacheStrategy, cacheConfig);
+      }
+      return {
+        data,
+        fromCache: false,
+        version: resolvedVersion
+      };
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (lastError.message.includes("not found") || lastError.message.includes("Unauthorized") || lastError.message.includes("Forbidden")) {
+        throw lastError;
+      }
+      if (attempt < fullRetryConfig.maxRetries) {
+        const delay = calculateBackoffDelay(attempt, fullRetryConfig);
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError || new Error("Failed to fetch component");
+}
+async function prefetchComponents(ids, options = {}) {
+  const promises = ids.map(
+    ({ id, version }) => fetchComponent(id, { ...options, version }).catch((error) => {
+      console.warn(`Failed to prefetch component ${id}:`, error);
+    })
+  );
+  await Promise.all(promises);
+}
+async function isComponentAvailable(id, version = "latest", options = {}) {
+  const { cacheStrategy = "memory", cacheConfig = DEFAULT_CACHE_CONFIG } = options;
+  const cached = getFromCache(id, version, cacheStrategy, cacheConfig);
+  if (cached) {
+    return { available: true, cached: true };
+  }
+  try {
+    await fetchComponent(id, {
+      ...options,
+      version,
+      retryConfig: { maxRetries: 0 }
+    });
+    return { available: true, cached: false };
+  } catch {
+    return { available: false, cached: false };
+  }
+}
+
+// src/testRunner.ts
+function runTestCase(elements, testCase, container) {
+  const startTime = performance.now();
+  const assertionResults = [];
+  let renderResult = null;
+  let error;
+  const testContainer = container || document.createElement("div");
+  if (!container) {
+    document.body.appendChild(testContainer);
+  }
+  try {
+    const context = {
+      props: testCase.props
+    };
+    renderResult = render({
+      container: testContainer,
+      elements,
+      context
+    });
+    for (const assertion of testCase.assertions) {
+      const result = validateAssertion(testContainer, assertion);
+      assertionResults.push(result);
+    }
+  } catch (err) {
+    error = err instanceof Error ? err.message : String(err);
+  } finally {
+    if (renderResult) {
+      renderResult.destroy();
+    }
+    if (!container) {
+      document.body.removeChild(testContainer);
+    }
+  }
+  const duration = performance.now() - startTime;
+  const passed = !error && assertionResults.every((r) => r.passed);
+  return {
+    testId: testCase.id,
+    testName: testCase.name,
+    passed,
+    assertions: assertionResults,
+    duration,
+    error
+  };
+}
+function runAllTests(elements, testCases) {
+  const startTime = performance.now();
+  const results = [];
+  for (const testCase of testCases) {
+    const result = runTestCase(elements, testCase);
+    results.push(result);
+  }
+  const duration = performance.now() - startTime;
+  const passed = results.filter((r) => r.passed).length;
+  const failed = results.filter((r) => !r.passed).length;
+  return {
+    total: testCases.length,
+    passed,
+    failed,
+    duration,
+    results
+  };
+}
+function validateAssertion(container, assertion) {
+  const elements = container.querySelectorAll(assertion.selector);
+  switch (assertion.type) {
+    case "exists":
+      return {
+        assertion,
+        passed: elements.length > 0,
+        actual: elements.length > 0,
+        expected: true,
+        message: elements.length > 0 ? `Element "${assertion.selector}" exists` : `Element "${assertion.selector}" not found`
+      };
+    case "count":
+      const count = elements.length;
+      const expectedCount = assertion.expected;
+      return {
+        assertion,
+        passed: count === expectedCount,
+        actual: count,
+        expected: expectedCount,
+        message: count === expectedCount ? `Found ${count} elements matching "${assertion.selector}"` : `Expected ${expectedCount} elements, found ${count}`
+      };
+    case "text":
+      if (elements.length === 0) {
+        return {
+          assertion,
+          passed: false,
+          actual: null,
+          expected: assertion.expected,
+          message: `Element "${assertion.selector}" not found`
+        };
+      }
+      const textContent = elements[0].textContent?.trim();
+      const expectedText = assertion.expected;
+      return {
+        assertion,
+        passed: textContent === expectedText,
+        actual: textContent,
+        expected: expectedText,
+        message: textContent === expectedText ? `Text matches: "${expectedText}"` : `Expected text "${expectedText}", got "${textContent}"`
+      };
+    case "attribute":
+      if (elements.length === 0) {
+        return {
+          assertion,
+          passed: false,
+          actual: null,
+          expected: assertion.expected,
+          message: `Element "${assertion.selector}" not found`
+        };
+      }
+      const attrValue = elements[0].getAttribute(assertion.attribute || "");
+      const expectedAttr = assertion.expected;
+      return {
+        assertion,
+        passed: attrValue === expectedAttr,
+        actual: attrValue,
+        expected: expectedAttr,
+        message: attrValue === expectedAttr ? `Attribute "${assertion.attribute}" matches` : `Expected attribute "${assertion.attribute}" to be "${expectedAttr}", got "${attrValue}"`
+      };
+    case "class":
+      if (elements.length === 0) {
+        return {
+          assertion,
+          passed: false,
+          actual: null,
+          expected: assertion.expected,
+          message: `Element "${assertion.selector}" not found`
+        };
+      }
+      const hasClass = elements[0].classList.contains(assertion.expected);
+      return {
+        assertion,
+        passed: hasClass,
+        actual: Array.from(elements[0].classList),
+        expected: assertion.expected,
+        message: hasClass ? `Element has class "${assertion.expected}"` : `Element does not have class "${assertion.expected}"`
+      };
+    case "style":
+      if (elements.length === 0) {
+        return {
+          assertion,
+          passed: false,
+          actual: null,
+          expected: assertion.expected,
+          message: `Element "${assertion.selector}" not found`
+        };
+      }
+      const el = elements[0];
+      const styleValue = el.style.getPropertyValue(assertion.property || "");
+      const expectedStyle = assertion.expected;
+      return {
+        assertion,
+        passed: styleValue === expectedStyle,
+        actual: styleValue,
+        expected: expectedStyle,
+        message: styleValue === expectedStyle ? `Style "${assertion.property}" matches` : `Expected style "${assertion.property}" to be "${expectedStyle}", got "${styleValue}"`
+      };
+    case "visible":
+      if (elements.length === 0) {
+        return {
+          assertion,
+          passed: false,
+          actual: null,
+          expected: true,
+          message: `Element "${assertion.selector}" not found`
+        };
+      }
+      const visible = isElementVisible(elements[0]);
+      const expectedVisible = assertion.expected !== false;
+      return {
+        assertion,
+        passed: visible === expectedVisible,
+        actual: visible,
+        expected: expectedVisible,
+        message: visible === expectedVisible ? `Element visibility matches expected` : `Expected element to be ${expectedVisible ? "visible" : "hidden"}`
+      };
+    default:
+      return {
+        assertion,
+        passed: false,
+        message: `Unknown assertion type: ${assertion.type}`
+      };
+  }
+}
+function isElementVisible(element) {
+  const style = window.getComputedStyle(element);
+  return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0" && element.offsetWidth > 0 && element.offsetHeight > 0;
+}
+function validateProps(props, definitions) {
+  const errors = [];
+  for (const def of definitions) {
+    const value = props[def.name];
+    if (def.required && (value === void 0 || value === null)) {
+      errors.push(`Required prop "${def.name}" is missing`);
+      continue;
+    }
+    if (value === void 0) continue;
+    const actualType = Array.isArray(value) ? "array" : typeof value;
+    if (def.type === "array" && !Array.isArray(value)) {
+      errors.push(`Prop "${def.name}" should be an array, got ${actualType}`);
+    } else if (def.type !== "array" && actualType !== def.type) {
+      errors.push(`Prop "${def.name}" should be ${def.type}, got ${actualType}`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function generateTestCases(definitions) {
+  const testCases = [];
+  const defaultProps = {};
+  for (const def of definitions) {
+    if (def.defaultValue !== void 0) {
+      defaultProps[def.name] = def.defaultValue;
+    }
+  }
+  testCases.push({
+    id: "default-props",
+    name: "Render with default props",
+    props: defaultProps,
+    assertions: [{ type: "exists", selector: "*" }]
+  });
+  for (const def of definitions) {
+    const sampleValue = getSampleValue(def);
+    if (sampleValue !== void 0) {
+      testCases.push({
+        id: `prop-${def.name}`,
+        name: `Test prop: ${def.name}`,
+        props: { ...defaultProps, [def.name]: sampleValue },
+        assertions: [{ type: "exists", selector: "*" }]
+      });
+    }
+  }
+  return testCases;
+}
+function getSampleValue(def) {
+  switch (def.type) {
+    case "string":
+      return "Sample Text";
+    case "number":
+      return 42;
+    case "boolean":
+      return true;
+    case "array":
+      return [];
+    case "object":
+      return {};
+    default:
+      return def.defaultValue;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CACHE_CONFIG,
+  DEFAULT_RETRY_CONFIG,
+  applyStyles,
+  buildClassName,
+  buildElementStyles,
+  bumpVersion,
+  camelToKebab,
+  clearAllCaches,
+  clearLocalStorageCache,
+  clearMemoryCache,
+  clearStyles,
+  compareVersions,
+  extractBindingKeys,
+  fetchComponent,
+  formatStyleValue,
+  formatVersion,
+  generateTestCases,
+  getCacheKey,
+  getFromCache,
+  getMemoryCacheSize,
+  getRegistryUrl,
+  hasTemplateSyntax,
+  invalidateCache,
+  isComponentAvailable,
+  isValidSpecifier,
+  parseVersion,
+  prefetchComponents,
+  processStyles,
+  render,
+  resolveBindingPath,
+  resolveTemplate,
+  resolveTemplateValue,
+  resolveTemplatesDeep,
+  resolveVersion,
+  runAllTests,
+  runTestCase,
+  satisfiesVersion,
+  setInCache,
+  setRegistryUrl,
+  updateStyles,
+  validateAssertion,
+  validateProps
+});