draft-ole 0.9.0

package/dist/index.js

@@ -0,0 +1,2573 @@
+import {
+  AppDocument,
+  app
+} from "./chunk-5BNNDTRT.js";
+import {
+  Alignment,
+  AppSlot,
+  Button,
+  HStack,
+  Heading,
+  Image,
+  Link,
+  PageDocument,
+  Section,
+  Spacer,
+  Text as Text2,
+  VStack,
+  ZStackAlignment,
+  divider,
+  hstack,
+  page,
+  spacer,
+  vstack,
+  zstack
+} from "./chunk-YK4Y4ENL.js";
+import {
+  ARIA_ATTRIBUTE_KEYS,
+  BOOLEAN_ATTRIBUTE_KEYS,
+  BUTTON_TYPES,
+  Breakpoints,
+  CSSAnimation,
+  CSSBackground,
+  CSSBorder,
+  CSSFlex,
+  CSSFont,
+  CSSGrid,
+  CSSList,
+  CSSPropertyKey,
+  CSSSpacing,
+  CSSTable,
+  CSSText,
+  CSSTransform,
+  CSSVisibility,
+  CSSVisual,
+  CssConfig,
+  CssManager,
+  CssPositionMaker,
+  CssStyleManager,
+  DraftOleError,
+  DuplicateCssPropertyError,
+  ExportableError,
+  FileExporter,
+  HTMLFormatter,
+  HtmlAttribute,
+  HtmlStyle,
+  HtmlTag,
+  INPUT_TYPES,
+  JQueryHelper,
+  JQueryManager,
+  KEY_VALUE_ATTRIBUTE_KEYS,
+  PairType,
+  PseudoStyleBuilder,
+  SELF_CLOSING_TAGS,
+  SelfClosingType,
+  TAG_TYPES,
+  Text,
+  TextType,
+  __export,
+  a,
+  abbr,
+  address,
+  area,
+  article,
+  aside,
+  audio,
+  b,
+  base,
+  blockquote,
+  body,
+  br,
+  button,
+  canvas,
+  caption,
+  cite,
+  code,
+  col,
+  colgroup,
+  createBooleanValue,
+  createCustomValue,
+  createKeyValueValue,
+  createVanillaScript,
+  datalist,
+  dd,
+  decodeJsParamSentinel,
+  details,
+  dialog,
+  div,
+  djb2Hash,
+  dl,
+  dt,
+  em,
+  embed,
+  escapeHtml,
+  fieldset,
+  figcaption,
+  figure,
+  footer,
+  form,
+  generateScopedClassName,
+  getTagStructure,
+  guardDuplicateCssProperty,
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6,
+  head,
+  header,
+  hlUnitToCssString,
+  hr,
+  html,
+  i,
+  iframe,
+  img,
+  input,
+  isJsParam,
+  kbd,
+  label,
+  legend,
+  li,
+  link,
+  main,
+  mark,
+  meta,
+  nav,
+  normalizeClassNames,
+  noscript,
+  ol,
+  optgroup,
+  option,
+  output,
+  p,
+  picture,
+  pre,
+  q,
+  ref,
+  s,
+  samp,
+  sanitizeCssValue,
+  script,
+  section,
+  select,
+  small,
+  source,
+  span,
+  strong,
+  sub,
+  summary,
+  sup,
+  svg,
+  table,
+  tags,
+  tbody,
+  td,
+  textarea,
+  tfoot,
+  th,
+  thead,
+  time,
+  title,
+  tr,
+  track,
+  u,
+  ul,
+  varTag,
+  video,
+  wbr,
+  wrapDOMReady
+} from "./chunk-STLTIBMA.js";
+
+// src/html/attributes/attribute-builder-base.ts
+var BaseAttributeBuilder = class {
+  /** Accumulated attributes (excluding class, which is handled separately) */
+  _attributes = [];
+  /** Accumulated class names (deduplicated and normalized on build) */
+  _classNames = [];
+  // ── Key-Value Helper ──
+  /**
+   * Adds a key-value HTML attribute.
+   *
+   * @param key - The attribute name
+   * @param value - The attribute value
+   * @returns This builder for method chaining
+   *
+   * @remarks
+   * This helper centralizes the keyValue attribute creation pattern.
+   * Subclasses may also use this helper for their own key-value attributes.
+   */
+  addKeyValue(key, value) {
+    this._attributes.push(HtmlAttribute.keyValue(key, String(value)));
+    return this;
+  }
+  // ── Common Attributes ──
+  /**
+   * Sets the id attribute.
+   *
+   * @param id - The element ID
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setId('main-content');
+   * // Produces: id="main-content"
+   * ```
+   */
+  setId(id) {
+    return this.addKeyValue("id", id);
+  }
+  /**
+   * Sets the title attribute (tooltip text).
+   *
+   * @param title - The tooltip text
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setTitle('Click to expand');
+   * // Produces: title="Click to expand"
+   * ```
+   */
+  setTitle(title2) {
+    return this.addKeyValue("title", title2);
+  }
+  /**
+   * Sets the lang attribute (language code).
+   *
+   * @param lang - The language code (e.g., 'en', 'ja', 'fr')
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setLang('ja');
+   * // Produces: lang="ja"
+   * ```
+   */
+  setLang(lang) {
+    return this.addKeyValue("lang", lang);
+  }
+  /**
+   * Sets the role attribute (ARIA role).
+   *
+   * @param role - The ARIA role (e.g., 'button', 'navigation')
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setRole('navigation');
+   * // Produces: role="navigation"
+   * ```
+   */
+  setRole(role) {
+    return this.addKeyValue("role", role);
+  }
+  /**
+   * Sets the tabindex attribute.
+   *
+   * @param index - The tab order index (-1 for programmatically focusable, 0 for natural order)
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setTabindex(0);  // Natural tab order
+   * builder.setTabindex(-1); // Programmatically focusable only
+   * ```
+   */
+  setTabindex(index) {
+    return this.addKeyValue("tabindex", index);
+  }
+  /**
+   * Sets the hidden boolean attribute.
+   *
+   * @param hidden - If true, adds the hidden attribute
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setHidden(true);  // Produces: hidden
+   * builder.setHidden(false); // No attribute added
+   * ```
+   */
+  setHidden(hidden) {
+    if (hidden) {
+      this._attributes.push(HtmlAttribute.boolean("hidden"));
+    }
+    return this;
+  }
+  // ── Custom Attributes ──
+  /**
+   * Sets a custom data-* attribute.
+   *
+   * @param name - The data attribute name (without 'data-' prefix)
+   * @param value - The attribute value
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setCustomAttribute('theme', 'dark');
+   * // Produces: data-theme="dark"
+   *
+   * builder.setCustomAttribute('user-id', '12345');
+   * // Produces: data-user-id="12345"
+   * ```
+   */
+  setCustomAttribute(name, value) {
+    this._attributes.push(HtmlAttribute.custom(name, value));
+    return this;
+  }
+  // ── ARIA Attributes ──
+  /**
+   * Sets the aria-label attribute.
+   *
+   * @param label - The accessible label text
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setAriaLabel('Close dialog');
+   * // Produces: aria-label="Close dialog"
+   * ```
+   */
+  setAriaLabel(label2) {
+    this._attributes.push(HtmlAttribute.ariaLabel(label2));
+    return this;
+  }
+  /**
+   * Sets the aria-hidden attribute.
+   *
+   * @param hidden - Whether the element should be hidden from assistive technologies
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setAriaHidden(true);
+   * // Produces: aria-hidden="true"
+   * ```
+   */
+  setAriaHidden(hidden) {
+    this._attributes.push(HtmlAttribute.ariaHidden(hidden));
+    return this;
+  }
+  /**
+   * Sets the aria-expanded attribute.
+   *
+   * @param expanded - Whether the element is currently expanded
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setAriaExpanded(false);
+   * // Produces: aria-expanded="false"
+   * ```
+   */
+  setAriaExpanded(expanded) {
+    this._attributes.push(HtmlAttribute.ariaExpanded(expanded));
+    return this;
+  }
+  // ── Class Management (4 Patterns) ──
+  /**
+   * Adds one or more class names (variadic pattern).
+   *
+   * @param classNames - One or more class name strings
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.addClass('btn', 'btn-primary', 'btn-large');
+   * // Accumulates: ['btn', 'btn-primary', 'btn-large']
+   * ```
+   */
+  addClass(...classNames) {
+    this._classNames.push(...classNames);
+    return this;
+  }
+  /**
+   * Adds class names from an array (array pattern).
+   *
+   * @param classNames - Array of class name strings
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * const classes = ['container', 'mx-auto', 'px-4'];
+   * builder.addClasses(classes);
+   * ```
+   */
+  addClasses(classNames) {
+    this._classNames.push(...classNames);
+    return this;
+  }
+  /**
+   * Conditionally adds a class name (conditional pattern).
+   *
+   * @param className - The class name to add
+   * @param condition - Only adds the class if this is true
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * const isActive = true;
+   * builder.addClassWhen('active', isActive);  // Adds 'active'
+   * builder.addClassWhen('disabled', false);   // Doesn't add
+   * ```
+   */
+  addClassWhen(className, condition) {
+    if (condition) {
+      this._classNames.push(className);
+    }
+    return this;
+  }
+  /**
+   * Adds classes from a toggle map (toggle pattern).
+   *
+   * @param classMap - Object mapping class names to boolean flags
+   * @returns This builder for method chaining
+   *
+   * @remarks
+   * Only class names with `true` values are added.
+   *
+   * @example
+   * ```typescript
+   * builder.addClassesToggle({
+   *   'btn-primary': isPrimary,
+   *   'btn-disabled': isDisabled,
+   *   'btn-large': isLarge
+   * });
+   * // Adds only classes where the value is true
+   * ```
+   */
+  addClassesToggle(classMap) {
+    for (const [name, enabled] of Object.entries(classMap)) {
+      if (enabled) {
+        this._classNames.push(name);
+      }
+    }
+    return this;
+  }
+  // ── Build ──
+  /**
+   * Builds and returns the accumulated attribute array.
+   *
+   * @returns Array of HtmlAttribute instances
+   *
+   * @remarks
+   * If any class names were added, they are normalized (trimmed, deduplicated)
+   * and merged into a single class attribute using {@link normalizeClassNames}.
+   *
+   * @example
+   * ```typescript
+   * const attrs = new BaseAttributeBuilder()
+   *   .setId('main')
+   *   .addClass('btn', 'btn-primary', 'btn')
+   *   .build();
+   * // Returns: [
+   * //   HtmlAttribute { key: 'id', ... },
+   * //   HtmlAttribute { key: 'class', value: 'btn btn-primary' }
+   * // ]
+   * ```
+   */
+  build() {
+    const result = [...this._attributes];
+    if (this._classNames.length > 0) {
+      result.push(HtmlAttribute.className(...this._classNames));
+    }
+    return result;
+  }
+};
+
+// src/html/attributes/attribute-builder-form.ts
+var FormAttributeBuilder = class extends BaseAttributeBuilder {
+  /**
+   * Sets the action attribute (form submission URL).
+   *
+   * @param action - The URL where the form data will be sent
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setAction('/api/submit');
+   * // Produces: action="/api/submit"
+   * ```
+   */
+  setAction(action) {
+    return this.addKeyValue("action", action);
+  }
+  /**
+   * Sets the method attribute (HTTP method).
+   *
+   * @param method - The HTTP method ('get' or 'post')
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setMethod('post');
+   * // Produces: method="post"
+   * ```
+   */
+  setMethod(method) {
+    return this.addKeyValue("method", method);
+  }
+  /**
+   * Sets the enctype attribute (encoding type).
+   *
+   * @param enctype - The encoding type (e.g., 'multipart/form-data', 'application/x-www-form-urlencoded')
+   * @returns This builder for method chaining
+   *
+   * @remarks
+   * Common values:
+   * - 'application/x-www-form-urlencoded' (default)
+   * - 'multipart/form-data' (for file uploads)
+   * - 'text/plain'
+   *
+   * @example
+   * ```typescript
+   * builder.setEnctype('multipart/form-data');
+   * // Produces: enctype="multipart/form-data"
+   * ```
+   */
+  setEnctype(enctype) {
+    return this.addKeyValue("enctype", enctype);
+  }
+};
+var InputAttributeBuilder = class extends BaseAttributeBuilder {
+  /**
+   * Sets the type attribute for the input element.
+   *
+   * @param type - A valid HTML input type
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setInputType('email');    // Produces: type="email"
+   * builder.setInputType('password'); // Produces: type="password"
+   * builder.setInputType('checkbox'); // Produces: type="checkbox"
+   * ```
+   *
+   * @see {@link InputType} for all valid types
+   */
+  setInputType(type) {
+    this._attributes.push(HtmlAttribute.inputType(type));
+    return this;
+  }
+  /**
+   * Sets the placeholder attribute.
+   *
+   * @param placeholder - The placeholder text
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setPlaceholder('Enter your email address');
+   * // Produces: placeholder="Enter your email address"
+   * ```
+   */
+  setPlaceholder(placeholder) {
+    return this.addKeyValue("placeholder", placeholder);
+  }
+  /**
+   * Sets the required boolean attribute.
+   *
+   * @param required - If true, adds the required attribute
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setRequired(true);  // Produces: required
+   * builder.setRequired(false); // No attribute added
+   * ```
+   */
+  setRequired(required) {
+    if (required) {
+      this._attributes.push(HtmlAttribute.boolean("required"));
+    }
+    return this;
+  }
+  /**
+   * Sets the pattern attribute (validation regex).
+   *
+   * @param pattern - A regular expression pattern for validation
+   * @returns This builder for method chaining
+   *
+   * @remarks
+   * The pattern is matched against the entire input value (implicit ^ and $).
+   *
+   * @example
+   * ```typescript
+   * // Require at least one uppercase, one lowercase, one digit
+   * builder.setPattern('^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).{8,}$');
+   *
+   * // Require specific format
+   * builder.setPattern('[0-9]{3}-[0-9]{4}'); // Matches: 123-4567
+   * ```
+   */
+  setPattern(pattern) {
+    return this.addKeyValue("pattern", pattern);
+  }
+  /**
+   * Sets the minlength attribute.
+   *
+   * @param length - Minimum number of characters required
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setMinLength(8);
+   * // Produces: minlength="8"
+   * ```
+   */
+  setMinLength(length) {
+    return this.addKeyValue("minlength", length);
+  }
+  /**
+   * Sets the maxlength attribute.
+   *
+   * @param length - Maximum number of characters allowed
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setMaxLength(100);
+   * // Produces: maxlength="100"
+   * ```
+   */
+  setMaxLength(length) {
+    return this.addKeyValue("maxlength", length);
+  }
+};
+var ButtonAttributeBuilder = class extends BaseAttributeBuilder {
+  /**
+   * Sets the type attribute for the button element.
+   *
+   * @param type - The button type ('submit', 'reset', or 'button')
+   * @returns This builder for method chaining
+   *
+   * @remarks
+   * - 'submit' - Submits the form (default if inside a form)
+   * - 'reset' - Resets form fields to their initial values
+   * - 'button' - No default behavior (use for custom JavaScript)
+   *
+   * @example
+   * ```typescript
+   * builder.setButtonType('submit');
+   * // Produces: type="submit"
+   *
+   * builder.setButtonType('button');
+   * // Produces: type="button"
+   * // Good for buttons that trigger JavaScript, not form submission
+   * ```
+   *
+   * @see {@link ButtonType} for all valid types
+   */
+  setButtonType(type) {
+    this._attributes.push(HtmlAttribute.buttonType(type));
+    return this;
+  }
+};
+
+// src/html/attributes/attribute-builder-media.ts
+var ImageAttributeBuilder = class extends BaseAttributeBuilder {
+  /**
+   * Sets the src attribute (image source URL).
+   *
+   * @param src - The URL of the image
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setSrc('/images/logo.png');
+   * // Produces: src="/images/logo.png"
+   *
+   * builder.setSrc('https://example.com/photo.jpg');
+   * // Produces: src="https://example.com/photo.jpg"
+   * ```
+   */
+  setSrc(src) {
+    return this.addKeyValue("src", src);
+  }
+  /**
+   * Sets the alt attribute (alternative text).
+   *
+   * @param alt - Descriptive text for the image (important for accessibility)
+   * @returns This builder for method chaining
+   *
+   * @remarks
+   * The alt attribute is crucial for accessibility. It should:
+   * - Describe the image content for screen readers
+   * - Be empty ("") for decorative images
+   * - Not include "image of" or "picture of"
+   *
+   * @example
+   * ```typescript
+   * builder.setAlt('Company logo');
+   * // Produces: alt="Company logo"
+   *
+   * builder.setAlt(''); // Decorative image
+   * // Produces: alt=""
+   * ```
+   */
+  setAlt(alt) {
+    return this.addKeyValue("alt", alt);
+  }
+  /**
+   * Sets the width attribute.
+   *
+   * @param width - Image width in pixels (number or string)
+   * @returns This builder for method chaining
+   *
+   * @remarks
+   * Setting explicit width and height helps prevent layout shift during page load.
+   *
+   * @example
+   * ```typescript
+   * builder.setWidth(800);    // Produces: width="800"
+   * builder.setWidth('100%'); // Produces: width="100%"
+   * ```
+   */
+  setWidth(width) {
+    return this.addKeyValue("width", width);
+  }
+  /**
+   * Sets the height attribute.
+   *
+   * @param height - Image height in pixels (number or string)
+   * @returns This builder for method chaining
+   *
+   * @remarks
+   * Setting explicit width and height helps prevent layout shift during page load.
+   *
+   * @example
+   * ```typescript
+   * builder.setHeight(600);   // Produces: height="600"
+   * builder.setHeight('auto'); // Produces: height="auto"
+   * ```
+   */
+  setHeight(height) {
+    return this.addKeyValue("height", height);
+  }
+  /**
+   * Sets the loading attribute (lazy loading strategy).
+   *
+   * @param loading - Loading strategy ('lazy' or 'eager')
+   * @returns This builder for method chaining
+   *
+   * @remarks
+   * - 'lazy' - Defer loading until the image is near the viewport (improves performance)
+   * - 'eager' - Load immediately (default browser behavior)
+   *
+   * @example
+   * ```typescript
+   * builder.setLoading('lazy');
+   * // Produces: loading="lazy"
+   * // Good for below-the-fold images
+   *
+   * builder.setLoading('eager');
+   * // Produces: loading="eager"
+   * // Good for above-the-fold images
+   * ```
+   */
+  setLoading(loading) {
+    return this.addKeyValue("loading", loading);
+  }
+};
+var LinkAttributeBuilder = class extends BaseAttributeBuilder {
+  /**
+   * Sets the href attribute (link destination).
+   *
+   * @param href - The URL of the linked resource
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setHref('/about');
+   * // Produces: href="/about"
+   *
+   * builder.setHref('https://example.com');
+   * // Produces: href="https://example.com"
+   *
+   * builder.setHref('#section-2');
+   * // Produces: href="#section-2"
+   * ```
+   */
+  setHref(href) {
+    return this.addKeyValue("href", href);
+  }
+  /**
+   * Sets the rel attribute (relationship).
+   *
+   * @param rel - The relationship type(s) (space-separated)
+   * @returns This builder for method chaining
+   *
+   * @remarks
+   * Common values:
+   * - 'stylesheet' - CSS stylesheet
+   * - 'icon' - Favicon
+   * - 'noopener' - Prevents window.opener access (security)
+   * - 'noreferrer' - Prevents referer header
+   * - 'nofollow' - Search engine hint
+   *
+   * @example
+   * ```typescript
+   * builder.setRel('stylesheet');
+   * // Produces: rel="stylesheet"
+   *
+   * builder.setRel('noopener noreferrer');
+   * // Produces: rel="noopener noreferrer"
+   * ```
+   */
+  setRel(rel) {
+    return this.addKeyValue("rel", rel);
+  }
+  /**
+   * Sets the type attribute (MIME type).
+   *
+   * @param type - The MIME type of the linked resource
+   * @returns This builder for method chaining
+   *
+   * @example
+   * ```typescript
+   * builder.setType('text/css');
+   * // Produces: type="text/css"
+   *
+   * builder.setType('application/rss+xml');
+   * // Produces: type="application/rss+xml"
+   * ```
+   */
+  setType(type) {
+    return this.addKeyValue("type", type);
+  }
+  /**
+   * Sets the media attribute (media query).
+   *
+   * @param media - CSS media query for when the link applies
+   * @returns This builder for method chaining
+   *
+   * @remarks
+   * Used primarily with `<link>` elements to conditionally load resources.
+   *
+   * @example
+   * ```typescript
+   * builder.setMedia('screen and (min-width: 768px)');
+   * // Produces: media="screen and (min-width: 768px)"
+   *
+   * builder.setMedia('print');
+   * // Produces: media="print"
+   * ```
+   */
+  setMedia(media2) {
+    return this.addKeyValue("media", media2);
+  }
+};
+
+// src/css/manager/default-css-manager.ts
+var noopLayout = {
+  tagPath: "",
+  get description() {
+    return {};
+  },
+  updateLLRegister(_register) {
+  },
+  getLLRegister() {
+    return void 0;
+  },
+  placeAbsoluteWith(_closure) {
+  },
+  placeRelativeWith(_closure) {
+  },
+  placeStaticWith(_closure) {
+  },
+  placeFixedWith(_closure) {
+  },
+  render() {
+    return "";
+  }
+};
+var noopStyleManager = {
+  get style() {
+    return { render() {
+      return "";
+    } };
+  },
+  getFontSizeUnit() {
+    return void 0;
+  },
+  render() {
+    return "";
+  }
+};
+var DefaultCssManager = class {
+  /** タグの階層パス（常に空文字列） */
+  tagPath = "";
+  /** no-opレイアウトマネージャー */
+  layout = noopLayout;
+  /** no-opスタイルマネージャー */
+  styleManager = noopStyleManager;
+  /**
+   * タグパスを更新する（no-op）
+   * @param newPath - 新しいタグパス
+   */
+  updateTagPath(newPath) {
+    this.tagPath = newPath;
+  }
+  /**
+   * 遅延レイアウトレジスタを更新する（no-op）
+   * @param _register - 遅延レイアウトレジスタ
+   */
+  updateLazyLayoutRegister(_register) {
+  }
+  /**
+   * CSS文字列をレンダリングする（常に空文字列を返す）
+   * @returns 空文字列
+   */
+  render() {
+    return "";
+  }
+  /**
+   * スコープドCSS文字列をレンダリングする（常に空文字列を返す）
+   * @returns 空文字列
+   */
+  renderCss() {
+    return "";
+  }
+  /**
+   * @media ルールを追加する（no-op）
+   * @param _breakpointPx - ブレークポイント（px 値）
+   * @param _props - 追加するCSSプロパティのマップ
+   */
+  addMediaRule(_breakpointPx, _props) {
+  }
+};
+
+// src/css/style/color/css-color-name.ts
+var CSSColorName = {
+  // 基本色
+  black: "black",
+  white: "white",
+  red: "red",
+  green: "green",
+  blue: "blue",
+  yellow: "yellow",
+  cyan: "cyan",
+  magenta: "magenta",
+  orange: "orange",
+  pink: "pink",
+  purple: "purple",
+  brown: "brown",
+  // グレー系
+  gray: "gray",
+  grey: "grey",
+  darkGray: "darkgray",
+  darkGrey: "darkgrey",
+  lightGray: "lightgray",
+  lightGrey: "lightgrey",
+  dimGray: "dimgray",
+  dimGrey: "dimgrey",
+  silver: "silver",
+  // 拡張色
+  navy: "navy",
+  teal: "teal",
+  maroon: "maroon",
+  olive: "olive",
+  lime: "lime",
+  aqua: "aqua",
+  fuchsia: "fuchsia",
+  coral: "coral",
+  salmon: "salmon",
+  gold: "gold",
+  indigo: "indigo",
+  violet: "violet",
+  crimson: "crimson",
+  turquoise: "turquoise",
+  // CSS特殊キーワード
+  transparent: "transparent",
+  currentColor: "currentColor",
+  inherit: "inherit"
+};
+var CSS_COLOR_NAME_VALUES = new Set(
+  Object.values(CSSColorName)
+);
+
+// src/css/style/color/css-color.ts
+var HEX_PATTERN = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+var RGB_PATTERN = /^rgb\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*\)$/;
+var RGBA_PATTERN = /^rgba\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*,\s*[\d.]+\s*\)$/;
+var CSSColor = class _CSSColor {
+  value;
+  /**
+   * @internal
+   * コンストラクタはプライベート。ファクトリメソッドを使用すること。
+   */
+  constructor(value) {
+    this.value = value;
+  }
+  // ── ファクトリメソッド ──
+  /**
+   * HEX値から CSSColor を生成する
+   *
+   * @param value - HEX色値（'#RGB', '#RRGGBB', '#RRGGBBAA' 形式）
+   * @returns CSSColor インスタンス
+   *
+   * @example
+   * ```ts
+   * CSSColor.hex('#f00');      // → "#f00" (短縮形)
+   * CSSColor.hex('#ff0000');   // → "#ff0000"
+   * CSSColor.hex('#ff0000ff'); // → "#ff0000ff" (アルファ付き)
+   * ```
+   */
+  static hex(value) {
+    return new _CSSColor(value);
+  }
+  /**
+   * RGB値から CSSColor を生成する
+   *
+   * @param r - Red (0-255)
+   * @param g - Green (0-255)
+   * @param b - Blue (0-255)
+   * @returns CSSColor インスタンス
+   *
+   * @example
+   * ```ts
+   * CSSColor.rgb(255, 0, 0); // → "rgb(255, 0, 0)"
+   * ```
+   */
+  static rgb(r, g, b2) {
+    return new _CSSColor(`rgb(${r}, ${g}, ${b2})`);
+  }
+  /**
+   * RGBA値から CSSColor を生成する
+   *
+   * @param r - Red (0-255)
+   * @param g - Green (0-255)
+   * @param b - Blue (0-255)
+   * @param a - Alpha (0-1)
+   * @returns CSSColor インスタンス
+   *
+   * @example
+   * ```ts
+   * CSSColor.rgba(255, 0, 0, 0.5); // → "rgba(255, 0, 0, 0.5)"
+   * ```
+   */
+  static rgba(r, g, b2, a2) {
+    return new _CSSColor(`rgba(${r}, ${g}, ${b2}, ${a2})`);
+  }
+  /**
+   * CSS標準色名から CSSColor を生成する
+   *
+   * @param name - CSS標準色名（{@link CSSColorNameValue}）
+   * @returns CSSColor インスタンス
+   *
+   * @example
+   * ```ts
+   * CSSColor.named('red');
+   * CSSColor.named('transparent');
+   * CSSColor.named('currentColor');
+   * ```
+   */
+  static named(name) {
+    return new _CSSColor(name);
+  }
+  /**
+   * 任意のCSS色文字列から CSSColor を生成する
+   *
+   * hsl(), var(), カスタムプロパティなど、任意のCSS色表現に対応。
+   *
+   * @param value - 任意のCSS色文字列
+   * @returns CSSColor インスタンス
+   *
+   * @example
+   * ```ts
+   * CSSColor.raw('hsl(0, 100%, 50%)');
+   * CSSColor.raw('var(--primary-color)');
+   * CSSColor.raw('currentColor');
+   * ```
+   */
+  static raw(value) {
+    return new _CSSColor(value);
+  }
+  // ── 検証メソッド ──
+  /**
+   * 値が HEX 形式かどうかを判定する
+   *
+   * @returns HEX形式の場合 true
+   */
+  isHex() {
+    return HEX_PATTERN.test(this.value);
+  }
+  /**
+   * 値が rgb() 形式かどうかを判定する
+   *
+   * @returns rgb() 形式の場合 true
+   */
+  isRgb() {
+    return RGB_PATTERN.test(this.value);
+  }
+  /**
+   * 値が rgba() 形式かどうかを判定する
+   *
+   * @returns rgba() 形式の場合 true
+   */
+  isRgba() {
+    return RGBA_PATTERN.test(this.value);
+  }
+  /**
+   * 値が CSS 標準色名かどうかを判定する
+   *
+   * @returns CSS標準色名の場合 true
+   */
+  isColorName() {
+    return CSS_COLOR_NAME_VALUES.has(this.value);
+  }
+  // ── CSS 文字列出力 ──
+  /**
+   * CSS色値の文字列表現を返す
+   *
+   * @returns CSS色値文字列
+   */
+  toString() {
+    return this.value;
+  }
+};
+
+// src/css/layout/lazy-layout/lazy-layout-manager.ts
+var LazyLayoutManager = class {
+  items = [];
+  /**
+   * レイアウトアイテムを登録する
+   *
+   * @param item - 登録するレイアウトアイテム
+   */
+  registerItem(item) {
+    this.items.push(item);
+  }
+  /**
+   * 指定されたタグパスの position 値を取得する
+   *
+   * @param tagPath - タグの階層パス
+   * @returns position 値（'static' | 'relative' | 'absolute' | 'fixed'）、または undefined
+   */
+  getRelationShip(tagPath) {
+    const found = this.getItemsBy(tagPath);
+    return found.length > 0 ? found[0]?.relationShip : void 0;
+  }
+  /**
+   * すべての遅延レイアウトを解決する
+   *
+   * 未解決の値（value が undefined）を持つアイテムを検索し、
+   * 依存関係を辿って値を解決する。循環依存が検出された場合は Error をスローする。
+   *
+   * @throws {Error} 循環依存が検出された場合
+   */
+  resolveAllLayout() {
+    for (let i2 = 0; i2 < this.items.length; i2++) {
+      const current = this.items[i2];
+      if (current === void 0) continue;
+      if (current.value === void 0) {
+        const resolvedValue = this.getValue(current.basePosition, current.targetTagPath, /* @__PURE__ */ new Set());
+        if (resolvedValue !== void 0) {
+          this.items[i2] = {
+            relationShip: current.relationShip,
+            baseTagPath: current.baseTagPath,
+            basePosition: current.basePosition,
+            targetTagPath: current.targetTagPath,
+            targetPosition: current.targetPosition,
+            value: resolvedValue
+          };
+        }
+      }
+    }
+  }
+  /**
+   * 指定されたタグパスのレイアウトアイテムをCSS文字列として出力する
+   *
+   * position プロパティは出力されない（個別要素用）。
+   *
+   * @param tagPath - タグの階層パス
+   * @returns CSS文字列（アイテムがない場合は空文字列）
+   */
+  renderItemsBy(tagPath) {
+    const items = this.getItemsBy(tagPath);
+    return this.renderLayoutByRegisteredItem(items, false);
+  }
+  /**
+   * すべてのレイアウトアイテムをCSS文字列として出力する
+   *
+   * position プロパティを含む完全なCSS出力（static 以外）。
+   *
+   * @returns CSS文字列（アイテムがない場合は空文字列）
+   */
+  renderAllItems() {
+    return this.renderLayoutByRegisteredItem(this.items, true);
+  }
+  // ── Private ──
+  getItemsBy(tagPath) {
+    return this.items.filter((item) => item.baseTagPath === tagPath);
+  }
+  getValue(needPosition, targetPath, visitedPaths) {
+    if (targetPath === void 0) return void 0;
+    if (visitedPaths.has(targetPath)) {
+      throw new Error(`Circular dependency detected: ${targetPath}`);
+    }
+    const targetItems = this.getItemsBy(targetPath);
+    if (targetItems.length === 0) return void 0;
+    const matchingItems = targetItems.filter((item) => item.basePosition === needPosition);
+    if (matchingItems.length === 0) return void 0;
+    const matchedItem = matchingItems[0];
+    if (matchedItem === void 0) return void 0;
+    if (matchedItem.value !== void 0) {
+      return matchedItem.value;
+    }
+    const newVisitedPaths = new Set(visitedPaths);
+    newVisitedPaths.add(targetPath);
+    return this.getValue(needPosition, matchedItem.targetTagPath, newVisitedPaths);
+  }
+  renderLayoutByRegisteredItem(items, includePosition) {
+    const entries = [];
+    let relationShipAdded = false;
+    for (const item of items) {
+      if (item.value === void 0) continue;
+      if (includePosition && !relationShipAdded && item.relationShip !== "static") {
+        entries.push(`position: ${item.relationShip}`);
+        relationShipAdded = true;
+      }
+      if (item.basePosition !== "none") {
+        entries.push(`${item.basePosition}: ${hlUnitToCssString(item.value)}`);
+      }
+    }
+    if (entries.length === 0) return "";
+    return entries.join(";\n") + ";";
+  }
+};
+
+// src/css/variables/style-template-label.ts
+function __draftole_label__(value, debugVarName) {
+  if (typeof value === "object" && value !== null && value._kind === "styleTemplate" && "bodyHash" in value) {
+    return Object.freeze({ ...value, debugVarName });
+  }
+  return value;
+}
+
+// src/css/variables/global-css.ts
+function brand(rendered) {
+  return rendered;
+}
+function toKebabCase(camel) {
+  return camel.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+}
+function renderProperties(properties) {
+  const lines = [];
+  for (const [key, value] of Object.entries(properties)) {
+    const safe = sanitizeCssValue(value);
+    if (safe === "") continue;
+    const kebab = toKebabCase(key);
+    lines.push(`  ${kebab}: ${safe};`);
+  }
+  return lines.join("\n");
+}
+function wrapBlock(selector, body2) {
+  return `${selector} {
+${body2}
+}`;
+}
+
+// src/css/variables/style-template.ts
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value) ?? "null";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((v) => stableStringify(v)).join(",")}]`;
+  }
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  const entries = keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`);
+  return `{${entries.join(",")}}`;
+}
+function computeBodyHash(properties, selectors) {
+  const normalized = stableStringify({
+    properties,
+    selectors: selectors ?? null
+  });
+  return djb2Hash(normalized);
+}
+function freezeProperties(properties) {
+  const snapshot = {};
+  for (const key of Object.keys(properties)) {
+    const value = properties[key];
+    if (value !== void 0) {
+      snapshot[key] = value;
+    }
+  }
+  return Object.freeze(snapshot);
+}
+function freezeSelectors(selectors) {
+  const snapshot = {};
+  for (const key of Object.keys(selectors)) {
+    const inner = selectors[key];
+    if (inner !== void 0) {
+      snapshot[key] = freezeProperties(inner);
+    }
+  }
+  return Object.freeze(snapshot);
+}
+function createStyleTemplate(input2) {
+  const { name, properties, selectors } = input2;
+  const frozenProperties = freezeProperties(properties);
+  const frozenSelectors = selectors !== void 0 ? freezeSelectors(selectors) : void 0;
+  const bodyHash = computeBodyHash(properties, selectors);
+  const template = {
+    _kind: "styleTemplate",
+    hasExplicitName: name !== void 0,
+    ...name !== void 0 ? { name } : {},
+    properties: frozenProperties,
+    ...frozenSelectors !== void 0 ? { selectors: frozenSelectors } : {},
+    bodyHash
+  };
+  return Object.freeze(template);
+}
+
+// src/css/variables/css-shared-style.ts
+function toKebabCase2(str) {
+  return str.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+}
+function renderCssBody(properties) {
+  return Object.entries(properties).filter(([, v]) => sanitizeCssValue(v) !== "").map(([k, v]) => `  ${toKebabCase2(k)}: ${sanitizeCssValue(v)};`).join("\n");
+}
+var PSEUDO_SELECTORS = /* @__PURE__ */ new Set([
+  "hover",
+  "focus",
+  "active",
+  "visited",
+  "disabled",
+  "first-child",
+  "last-child",
+  "focus-within",
+  "focus-visible"
+]);
+function resolveSelector(name, key) {
+  if (PSEUDO_SELECTORS.has(key)) {
+    return `.${name}:${key}`;
+  }
+  if (key.startsWith("&")) {
+    return `.${name}${key.slice(1)}`;
+  }
+  if (key.startsWith(" ")) {
+    return `.${name}${key}`;
+  }
+  return `.${name}:${key}`;
+}
+function createStyleNamed(name, properties, selectors) {
+  const parts = [];
+  const entries = Object.entries(properties);
+  if (entries.length > 0) {
+    parts.push(`.${name} {
+${renderCssBody(properties)}
+}`);
+  }
+  if (selectors) {
+    for (const [key, props] of Object.entries(selectors)) {
+      if (props && Object.keys(props).length > 0) {
+        const selector = resolveSelector(name, key);
+        parts.push(`${selector} {
+${renderCssBody(props)}
+}`);
+      }
+    }
+  }
+  const template = createStyleTemplate({
+    name,
+    properties,
+    ...selectors !== void 0 ? { selectors } : {}
+  });
+  return {
+    className: name,
+    css: parts.join("\n"),
+    _template: template,
+    toString() {
+      return name;
+    }
+  };
+}
+function createStyle(arg1, arg2, arg3) {
+  if (typeof arg1 === "string") {
+    const properties2 = arg2 ?? {};
+    return createStyleNamed(arg1, properties2, arg3);
+  }
+  const properties = arg1;
+  const selectors = arg2;
+  return createStyleTemplate({
+    properties,
+    ...selectors !== void 0 ? { selectors } : {}
+  });
+}
+
+// src/css/variables/unified-theme.ts
+var CSS_KEYWORDS = /* @__PURE__ */ new Set([
+  // CSS-wide keywords
+  "inherit",
+  "initial",
+  "unset",
+  "revert",
+  "revert-layer",
+  // generic
+  "auto",
+  "none",
+  "normal",
+  "currentcolor",
+  "transparent",
+  // display
+  "block",
+  "inline",
+  "inline-block",
+  "flex",
+  "inline-flex",
+  "grid",
+  "inline-grid",
+  "contents",
+  "flow-root",
+  "list-item",
+  "table",
+  "table-row",
+  "table-cell",
+  // visibility
+  "visible",
+  "hidden",
+  "collapse",
+  // position
+  "static",
+  "relative",
+  "absolute",
+  "fixed",
+  "sticky",
+  // font weight / style
+  "bold",
+  "bolder",
+  "lighter",
+  "italic",
+  "oblique",
+  // text
+  "left",
+  "right",
+  "center",
+  "justify",
+  "start",
+  "end",
+  // border style
+  "solid",
+  "dashed",
+  "dotted",
+  "double",
+  "groove",
+  "ridge",
+  "inset",
+  "outset",
+  // cursor
+  "pointer",
+  "default",
+  "crosshair",
+  "text",
+  "wait",
+  "help",
+  "move",
+  "not-allowed",
+  "grab",
+  "grabbing",
+  // overflow
+  "scroll",
+  "clip",
+  // flex / align
+  "stretch",
+  "baseline",
+  "space-between",
+  "space-around",
+  "space-evenly",
+  "flex-start",
+  "flex-end",
+  // box-sizing
+  "content-box",
+  "border-box",
+  // CSS named colors (subset commonly used)
+  "aliceblue",
+  "antiquewhite",
+  "aqua",
+  "aquamarine",
+  "azure",
+  "beige",
+  "bisque",
+  "black",
+  "blanchedalmond",
+  "blue",
+  "blueviolet",
+  "brown",
+  "burlywood",
+  "cadetblue",
+  "chartreuse",
+  "chocolate",
+  "coral",
+  "cornflowerblue",
+  "cornsilk",
+  "crimson",
+  "cyan",
+  "darkblue",
+  "darkcyan",
+  "darkgoldenrod",
+  "darkgray",
+  "darkgreen",
+  "darkgrey",
+  "darkkhaki",
+  "darkmagenta",
+  "darkolivegreen",
+  "darkorange",
+  "darkorchid",
+  "darkred",
+  "darksalmon",
+  "darkseagreen",
+  "darkslateblue",
+  "darkslategray",
+  "darkslategrey",
+  "darkturquoise",
+  "darkviolet",
+  "deeppink",
+  "deepskyblue",
+  "dimgray",
+  "dimgrey",
+  "dodgerblue",
+  "firebrick",
+  "floralwhite",
+  "forestgreen",
+  "fuchsia",
+  "gainsboro",
+  "ghostwhite",
+  "gold",
+  "goldenrod",
+  "gray",
+  "green",
+  "greenyellow",
+  "grey",
+  "honeydew",
+  "hotpink",
+  "indianred",
+  "indigo",
+  "ivory",
+  "khaki",
+  "lavender",
+  "lavenderblush",
+  "lawngreen",
+  "lemonchiffon",
+  "lightblue",
+  "lightcoral",
+  "lightcyan",
+  "lightgoldenrodyellow",
+  "lightgray",
+  "lightgreen",
+  "lightgrey",
+  "lightpink",
+  "lightsalmon",
+  "lightseagreen",
+  "lightskyblue",
+  "lightslategray",
+  "lightslategrey",
+  "lightsteelblue",
+  "lightyellow",
+  "lime",
+  "limegreen",
+  "linen",
+  "magenta",
+  "maroon",
+  "mediumaquamarine",
+  "mediumblue",
+  "mediumorchid",
+  "mediumpurple",
+  "mediumseagreen",
+  "mediumslateblue",
+  "mediumspringgreen",
+  "mediumturquoise",
+  "mediumvioletred",
+  "midnightblue",
+  "mintcream",
+  "mistyrose",
+  "moccasin",
+  "navajowhite",
+  "navy",
+  "oldlace",
+  "olive",
+  "olivedrab",
+  "orange",
+  "orangered",
+  "orchid",
+  "palegoldenrod",
+  "palegreen",
+  "paleturquoise",
+  "palevioletred",
+  "papayawhip",
+  "peachpuff",
+  "peru",
+  "pink",
+  "plum",
+  "powderblue",
+  "purple",
+  "rebeccapurple",
+  "red",
+  "rosybrown",
+  "royalblue",
+  "saddlebrown",
+  "salmon",
+  "sandybrown",
+  "seagreen",
+  "seashell",
+  "sienna",
+  "silver",
+  "skyblue",
+  "slateblue",
+  "slategray",
+  "slategrey",
+  "snow",
+  "springgreen",
+  "steelblue",
+  "tan",
+  "teal",
+  "thistle",
+  "tomato",
+  "turquoise",
+  "violet",
+  "wheat",
+  "white",
+  "whitesmoke",
+  "yellow",
+  "yellowgreen"
+]);
+var COLOR_PROPERTIES = /* @__PURE__ */ new Set([
+  "color",
+  "background",
+  "background-color",
+  "border-color",
+  "border-top-color",
+  "border-right-color",
+  "border-bottom-color",
+  "border-left-color",
+  "outline-color",
+  "text-decoration-color",
+  "caret-color",
+  "fill",
+  "stroke"
+]);
+var NON_COLOR_KEYWORDS = /* @__PURE__ */ new Set([
+  // cursor 専用
+  "text",
+  "pointer",
+  "default",
+  "crosshair",
+  "wait",
+  "help",
+  "move",
+  "not-allowed",
+  "grab",
+  "grabbing",
+  // display
+  "block",
+  "inline",
+  "inline-block",
+  "flex",
+  "inline-flex",
+  "grid",
+  "inline-grid",
+  "contents",
+  "flow-root",
+  "list-item",
+  "table",
+  "table-row",
+  "table-cell",
+  // visibility
+  "visible",
+  "hidden",
+  "collapse",
+  // position
+  "static",
+  "relative",
+  "absolute",
+  "fixed",
+  "sticky",
+  // overflow
+  "scroll",
+  "clip",
+  // flex / align
+  "stretch",
+  "baseline",
+  "space-between",
+  "space-around",
+  "space-evenly",
+  "flex-start",
+  "flex-end",
+  // box-sizing
+  "content-box",
+  "border-box",
+  // font-weight / style
+  "bold",
+  "bolder",
+  "lighter",
+  "italic",
+  "oblique",
+  // text-align
+  "left",
+  "right",
+  "center",
+  "justify",
+  "start",
+  "end",
+  // border-style
+  "solid",
+  "dashed",
+  "dotted",
+  "double",
+  "groove",
+  "ridge",
+  "inset",
+  "outset",
+  // generic non-color
+  "auto",
+  "normal"
+]);
+var COLOR_KEYWORDS = new Set(
+  Array.from(CSS_KEYWORDS).filter((k) => !NON_COLOR_KEYWORDS.has(k))
+);
+function getKeywordsForProperty(propName) {
+  const normalized = propName.toLowerCase();
+  if (COLOR_PROPERTIES.has(normalized)) {
+    return COLOR_KEYWORDS;
+  }
+  return CSS_KEYWORDS;
+}
+var defaultKeywordResolver = getKeywordsForProperty;
+function classifyEntry(key, value) {
+  if (typeof value === "string") {
+    return { kind: "token", key, value };
+  }
+  return { kind: "class", key, value };
+}
+var TokenAccumulator = class {
+  entries = /* @__PURE__ */ new Map();
+  add(name, rawValue) {
+    const safe = sanitizeCssValue(rawValue);
+    if (safe === "") return;
+    this.entries.set(name, safe);
+  }
+  buildRootCss() {
+    if (this.entries.size === 0) return void 0;
+    const lines = [];
+    for (const [k, v] of this.entries) {
+      lines.push(`  --${k}: ${v};`);
+    }
+    return brand(`:root {
+${lines.join("\n")}
+}`);
+  }
+  buildProxy() {
+    const proxy = {};
+    for (const k of this.entries.keys()) {
+      proxy[k] = `var(--${k})`;
+    }
+    return proxy;
+  }
+  getNameSet() {
+    return new Set(this.entries.keys());
+  }
+};
+function resolveTokenRefs(properties, tokenNames, keywordResolver) {
+  const out = {};
+  for (const [k, v] of Object.entries(properties)) {
+    out[k] = resolveValue(k, v, tokenNames, keywordResolver);
+  }
+  return out;
+}
+function resolveValue(propName, value, tokenNames, keywordResolver) {
+  if (/[\s(),]/.test(value)) return value;
+  const keywords = keywordResolver(propName);
+  if (keywords.has(value)) return value;
+  if (tokenNames.has(value)) return `var(--${value})`;
+  return value;
+}
+var ClassAccumulator = class {
+  entries = /* @__PURE__ */ new Map();
+  tokenNames = /* @__PURE__ */ new Set();
+  keywordResolver = defaultKeywordResolver;
+  setTokenContext(tokenNames, keywordResolver) {
+    this.tokenNames = tokenNames;
+    this.keywordResolver = keywordResolver;
+  }
+  add(name, properties) {
+    const resolved = resolveTokenRefs(properties, this.tokenNames, this.keywordResolver);
+    const style = createStyleNamed(name, resolved);
+    this.entries.set(name, style);
+  }
+  buildProxy() {
+    const proxy = {};
+    for (const [k, v] of this.entries) {
+      proxy[k] = v;
+    }
+    return proxy;
+  }
+  buildCssBlocks() {
+    const blocks = [];
+    for (const style of this.entries.values()) {
+      if (style.css !== "") blocks.push(brand(style.css));
+    }
+    return blocks;
+  }
+};
+function combineCss(parts) {
+  const sections = [];
+  if (parts.tokensCss !== void 0 && parts.tokensCss !== "") {
+    sections.push(parts.tokensCss);
+  }
+  for (const block of parts.classesCss) {
+    if (block !== "") sections.push(block);
+  }
+  return brand(sections.join("\n\n"));
+}
+function resolveSelectorsTokens(selectors, tokenNames, keywordResolver) {
+  const out = {};
+  for (const [k, props] of Object.entries(selectors)) {
+    if (props !== void 0) {
+      out[k] = resolveTokenRefs(props, tokenNames, keywordResolver);
+    }
+  }
+  return out;
+}
+function buildThemeClass(tokenNames, keywordResolver) {
+  function impl(arg1, arg2, arg3) {
+    if (typeof arg1 === "string") {
+      const name = arg1;
+      const properties2 = arg2 ?? {};
+      const selectors2 = arg3;
+      const resolvedProps2 = resolveTokenRefs(properties2, tokenNames, keywordResolver);
+      const resolvedSelectors2 = selectors2 !== void 0 ? resolveSelectorsTokens(selectors2, tokenNames, keywordResolver) : void 0;
+      return createStyleNamed(name, resolvedProps2, resolvedSelectors2);
+    }
+    const properties = arg1;
+    const selectors = arg2;
+    const resolvedProps = resolveTokenRefs(properties, tokenNames, keywordResolver);
+    const resolvedSelectors = selectors !== void 0 ? resolveSelectorsTokens(selectors, tokenNames, keywordResolver) : void 0;
+    return createStyleTemplate({
+      properties: resolvedProps,
+      ...resolvedSelectors !== void 0 ? { selectors: resolvedSelectors } : {}
+    });
+  }
+  return impl;
+}
+function buildUnifiedTheme(input2) {
+  const tokenAcc = new TokenAccumulator();
+  const classAcc = new ClassAccumulator();
+  const deferredClasses = [];
+  for (const [key, value] of Object.entries(input2)) {
+    const entry = classifyEntry(key, value);
+    if (entry.kind === "token") {
+      tokenAcc.add(entry.key, entry.value);
+    } else {
+      deferredClasses.push({ key: entry.key, value: entry.value });
+    }
+  }
+  classAcc.setTokenContext(tokenAcc.getNameSet(), defaultKeywordResolver);
+  for (const { key, value } of deferredClasses) {
+    classAcc.add(key, value);
+  }
+  const tokenProxy = tokenAcc.buildProxy();
+  const classProxy = classAcc.buildProxy();
+  const result = {};
+  for (const [k, v] of Object.entries(tokenProxy)) result[k] = v;
+  for (const [k, v] of Object.entries(classProxy)) result[k] = v;
+  const tokensCss = tokenAcc.buildRootCss();
+  const classesCss = classAcc.buildCssBlocks();
+  const css2 = combineCss({ tokensCss, classesCss });
+  Object.defineProperty(result, "css", {
+    value: css2,
+    enumerable: false,
+    writable: false
+  });
+  const themeClass = buildThemeClass(tokenAcc.getNameSet(), defaultKeywordResolver);
+  Object.defineProperty(result, "class", {
+    value: themeClass,
+    enumerable: false,
+    writable: false
+  });
+  return Object.freeze(result);
+}
+
+// src/css/variables/css-theme.ts
+function createTheme(input2) {
+  return buildUnifiedTheme(input2);
+}
+
+// src/css/variables/global-dsl.ts
+function selectorRule(selector, properties) {
+  return brand(wrapBlock(selector, renderProperties(properties)));
+}
+function root(properties) {
+  return selectorRule(":root", properties);
+}
+function all(properties) {
+  return selectorRule("*", properties);
+}
+function tag(name, properties) {
+  return selectorRule(name, properties);
+}
+function rule(selector, properties) {
+  return selectorRule(selector, properties);
+}
+function media(query, rules) {
+  const indented = rules.map(
+    (r) => r.split("\n").map((line) => `  ${line}`).join("\n")
+  ).join("\n\n");
+  return brand(`@media ${query} {
+${indented}
+}`);
+}
+function keyframes(name, frames) {
+  const blocks = Object.entries(frames).map(
+    ([key, props]) => {
+      const body2 = renderProperties(props).split("\n").map((line) => `  ${line}`).join("\n");
+      return `  ${key} {
+${body2}
+  }`;
+    }
+  );
+  return brand(`@keyframes ${name} {
+${blocks.join("\n")}
+}`);
+}
+
+// src/css/css.ts
+function cssRaw(cssString) {
+  return brand(cssString);
+}
+var DEFAULT_RESET = brand(
+  "* {\n  box-sizing: border-box;\n}\n\nbody {\n  margin: 0;\n}"
+);
+function isStyleTemplate(v) {
+  return typeof v === "object" && v !== null && v._kind === "styleTemplate";
+}
+function isSharedStyle(v) {
+  return typeof v === "object" && v !== null && typeof v.className === "string" && typeof v.css === "string";
+}
+function cssReset(arg) {
+  if (arg === void 0) return DEFAULT_RESET;
+  let properties;
+  if (isSharedStyle(arg)) {
+    properties = { ...arg._template.properties };
+  } else if (isStyleTemplate(arg)) {
+    properties = { ...arg.properties };
+  } else {
+    properties = arg;
+  }
+  return brand(wrapBlock("*", renderProperties(properties)));
+}
+function variant(_theme, selector, overrides) {
+  const lines = [];
+  for (const [key, rawValue] of Object.entries(overrides)) {
+    if (typeof rawValue !== "string") continue;
+    const safe = sanitizeCssValue(rawValue);
+    if (safe === "") continue;
+    lines.push(`  --${key}: ${safe};`);
+  }
+  return brand(wrapBlock(selector, lines.join("\n")));
+}
+function cssThemeImpl(input2) {
+  return createTheme(input2);
+}
+var cssTheme = Object.assign(cssThemeImpl, { variant });
+var cssClass = ((arg1, arg2, arg3) => {
+  if (typeof arg1 === "string") {
+    return createStyle(arg1, arg2 ?? {}, arg3);
+  }
+  return createStyle(arg1, arg2);
+});
+var css = {
+  theme: cssTheme,
+  class: cssClass,
+  reset: cssReset,
+  media,
+  keyframes,
+  raw: cssRaw
+};
+
+// src/html/protocols/jquery-method-type.ts
+var JQUERY_METHOD_TYPES = [
+  "css",
+  "height",
+  "on",
+  "text",
+  "html",
+  "addClass",
+  "removeClass",
+  "toggleClass"
+];
+
+// src/js/js-template.ts
+function param(name) {
+  return { __jsParam: true, name };
+}
+var DOM_PROPERTY_MAP = {
+  "className": "className",
+  "class": "className",
+  "textContent": "textContent",
+  "id": "id",
+  "type": "type",
+  "value": "value",
+  "href": "href",
+  "src": "src",
+  "alt": "alt",
+  "title": "title",
+  "placeholder": "placeholder",
+  "name": "name",
+  "disabled": "disabled",
+  "checked": "checked",
+  "selected": "selected",
+  "readonly": "readOnly",
+  "hidden": "hidden"
+};
+function renderAttrValue(raw) {
+  const paramName = decodeJsParamSentinel(raw);
+  if (paramName !== null) {
+    return paramName;
+  }
+  return JSON.stringify(raw);
+}
+function attrToJsLines(varName, attr) {
+  const key = attr.key;
+  const attrValue = attr.attributeValue;
+  if (attrValue.type === "boolean") {
+    const prop = DOM_PROPERTY_MAP[key] ?? key;
+    return [`${varName}.${prop} = true;`];
+  }
+  if (attrValue.type === "custom") {
+    const dataKey = `data-${attrValue.name}`;
+    const rawValue = attrValue.value;
+    const paramName = decodeJsParamSentinel(rawValue);
+    if (paramName !== null) {
+      return [`${varName}.setAttribute("${dataKey}", ${paramName});`];
+    }
+    return [`${varName}.setAttribute("${dataKey}", ${JSON.stringify(rawValue)});`];
+  }
+  if (attrValue.type === "keyValue") {
+    const rawValue = attrValue.value;
+    if (key === "class") {
+      return [`${varName}.className = ${renderAttrValue(rawValue)};`];
+    }
+    const domProp = DOM_PROPERTY_MAP[key];
+    if (domProp !== void 0) {
+      return [`${varName}.${domProp} = ${renderAttrValue(rawValue)};`];
+    }
+    const paramName = decodeJsParamSentinel(rawValue);
+    if (paramName !== null) {
+      return [`${varName}.setAttribute("${key}", ${paramName});`];
+    }
+    return [`${varName}.setAttribute("${key}", ${JSON.stringify(rawValue)});`];
+  }
+  return [];
+}
+function walkNode(node, counter, lines, refs) {
+  const jsNameAttr = node.attributes.find(
+    (a2) => a2.attributeValue.type === "custom" && a2.attributeValue.name === "jsname"
+  );
+  let varName;
+  if (jsNameAttr && jsNameAttr.attributeValue.type === "custom") {
+    varName = jsNameAttr.attributeValue.value;
+    refs[varName] = varName;
+  } else {
+    varName = `el${counter.value++}`;
+  }
+  const tagType = node.tagType;
+  lines.push(`const ${varName} = document.createElement("${tagType}");`);
+  for (const attr of node.attributes) {
+    if (attr.attributeValue.type === "custom" && attr.attributeValue.name === "jsname") continue;
+    const attrLines = attrToJsLines(varName, attr);
+    for (const line of attrLines) {
+      lines.push(line);
+    }
+  }
+  for (const child of node.children) {
+    if (child instanceof TextType) {
+      const content = child.content;
+      const paramName = decodeJsParamSentinel(content);
+      if (paramName !== null) {
+        lines.push(`${varName}.textContent = ${paramName};`);
+      } else {
+        lines.push(`${varName}.textContent = ${JSON.stringify(content)};`);
+      }
+    } else {
+      const childVar = walkNode(child, counter, lines, refs);
+      lines.push(`${varName}.appendChild(${childVar});`);
+    }
+  }
+  return varName;
+}
+function jsTemplate(name, params, rootElement, afterCreate) {
+  return {
+    name,
+    params: [...params],
+    render() {
+      const bodyLines = [];
+      const counter = { value: 0 };
+      const refs = {};
+      const rootVarName = walkNode(rootElement, counter, bodyLines, refs);
+      const paramsStr = params.join(", ");
+      const indented = bodyLines.map((l) => `  ${l}`).join("\n");
+      const parts = [
+        `function ${name}(${paramsStr}) {`,
+        indented
+      ];
+      if (afterCreate) {
+        const afterCode = afterCreate(refs);
+        if (afterCode.trim().length > 0) {
+          const afterLines = afterCode.split("\n").filter((l) => l.trim().length > 0).map((l) => `  ${l}`).join("\n");
+          parts.push(afterLines);
+        }
+      }
+      parts.push(`  return ${rootVarName};`);
+      parts.push("}");
+      return parts.join("\n");
+    }
+  };
+}
+
+// src/js/vanilla/emit-handler.ts
+function emitHandler(code2, params = []) {
+  return Object.assign(
+    (s2) => {
+      s2._emitHandlerBody(code2, params);
+    },
+    { _draftoleEmitted: true }
+  );
+}
+
+// src/css/variables/tag-dsl.generated.ts
+var tag_dsl_generated_exports = {};
+__export(tag_dsl_generated_exports, {
+  tagA: () => tagA,
+  tagAbbr: () => tagAbbr,
+  tagAddress: () => tagAddress,
+  tagArea: () => tagArea,
+  tagArticle: () => tagArticle,
+  tagAside: () => tagAside,
+  tagAudio: () => tagAudio,
+  tagB: () => tagB,
+  tagBase: () => tagBase,
+  tagBdi: () => tagBdi,
+  tagBdo: () => tagBdo,
+  tagBlockquote: () => tagBlockquote,
+  tagBody: () => tagBody,
+  tagBr: () => tagBr,
+  tagButton: () => tagButton,
+  tagCanvas: () => tagCanvas,
+  tagCaption: () => tagCaption,
+  tagCite: () => tagCite,
+  tagCode: () => tagCode,
+  tagCol: () => tagCol,
+  tagColgroup: () => tagColgroup,
+  tagData: () => tagData,
+  tagDatalist: () => tagDatalist,
+  tagDd: () => tagDd,
+  tagDel: () => tagDel,
+  tagDetails: () => tagDetails,
+  tagDfn: () => tagDfn,
+  tagDialog: () => tagDialog,
+  tagDiv: () => tagDiv,
+  tagDl: () => tagDl,
+  tagDt: () => tagDt,
+  tagEm: () => tagEm,
+  tagEmbed: () => tagEmbed,
+  tagFieldset: () => tagFieldset,
+  tagFigcaption: () => tagFigcaption,
+  tagFigure: () => tagFigure,
+  tagFooter: () => tagFooter,
+  tagForm: () => tagForm,
+  tagH1: () => tagH1,
+  tagH2: () => tagH2,
+  tagH3: () => tagH3,
+  tagH4: () => tagH4,
+  tagH5: () => tagH5,
+  tagH6: () => tagH6,
+  tagHead: () => tagHead,
+  tagHeader: () => tagHeader,
+  tagHgroup: () => tagHgroup,
+  tagHr: () => tagHr,
+  tagHtml: () => tagHtml,
+  tagI: () => tagI,
+  tagIframe: () => tagIframe,
+  tagImg: () => tagImg,
+  tagInput: () => tagInput,
+  tagIns: () => tagIns,
+  tagKbd: () => tagKbd,
+  tagLabel: () => tagLabel,
+  tagLegend: () => tagLegend,
+  tagLi: () => tagLi,
+  tagLink: () => tagLink,
+  tagMain: () => tagMain,
+  tagMap: () => tagMap,
+  tagMark: () => tagMark,
+  tagMenu: () => tagMenu,
+  tagMeta: () => tagMeta,
+  tagMeter: () => tagMeter,
+  tagNav: () => tagNav,
+  tagNoscript: () => tagNoscript,
+  tagObject: () => tagObject,
+  tagOl: () => tagOl,
+  tagOptgroup: () => tagOptgroup,
+  tagOption: () => tagOption,
+  tagOutput: () => tagOutput,
+  tagP: () => tagP,
+  tagPicture: () => tagPicture,
+  tagPre: () => tagPre,
+  tagProgress: () => tagProgress,
+  tagQ: () => tagQ,
+  tagRp: () => tagRp,
+  tagRt: () => tagRt,
+  tagRuby: () => tagRuby,
+  tagS: () => tagS,
+  tagSamp: () => tagSamp,
+  tagScript: () => tagScript,
+  tagSearch: () => tagSearch,
+  tagSection: () => tagSection,
+  tagSelect: () => tagSelect,
+  tagSlot: () => tagSlot,
+  tagSmall: () => tagSmall,
+  tagSource: () => tagSource,
+  tagSpan: () => tagSpan,
+  tagStrong: () => tagStrong,
+  tagStyle: () => tagStyle,
+  tagSub: () => tagSub,
+  tagSummary: () => tagSummary,
+  tagSup: () => tagSup,
+  tagTable: () => tagTable,
+  tagTbody: () => tagTbody,
+  tagTd: () => tagTd,
+  tagTemplate: () => tagTemplate,
+  tagTextarea: () => tagTextarea,
+  tagTfoot: () => tagTfoot,
+  tagTh: () => tagTh,
+  tagThead: () => tagThead,
+  tagTime: () => tagTime,
+  tagTitle: () => tagTitle,
+  tagTr: () => tagTr,
+  tagTrack: () => tagTrack,
+  tagU: () => tagU,
+  tagUl: () => tagUl,
+  tagVar: () => tagVar,
+  tagVideo: () => tagVideo,
+  tagWbr: () => tagWbr
+});
+var tagA = (properties) => tag("a", properties);
+var tagAbbr = (properties) => tag("abbr", properties);
+var tagAddress = (properties) => tag("address", properties);
+var tagArea = (properties) => tag("area", properties);
+var tagArticle = (properties) => tag("article", properties);
+var tagAside = (properties) => tag("aside", properties);
+var tagAudio = (properties) => tag("audio", properties);
+var tagB = (properties) => tag("b", properties);
+var tagBase = (properties) => tag("base", properties);
+var tagBdi = (properties) => tag("bdi", properties);
+var tagBdo = (properties) => tag("bdo", properties);
+var tagBlockquote = (properties) => tag("blockquote", properties);
+var tagBody = (properties) => tag("body", properties);
+var tagBr = (properties) => tag("br", properties);
+var tagButton = (properties) => tag("button", properties);
+var tagCanvas = (properties) => tag("canvas", properties);
+var tagCaption = (properties) => tag("caption", properties);
+var tagCite = (properties) => tag("cite", properties);
+var tagCode = (properties) => tag("code", properties);
+var tagCol = (properties) => tag("col", properties);
+var tagColgroup = (properties) => tag("colgroup", properties);
+var tagData = (properties) => tag("data", properties);
+var tagDatalist = (properties) => tag("datalist", properties);
+var tagDd = (properties) => tag("dd", properties);
+var tagDel = (properties) => tag("del", properties);
+var tagDetails = (properties) => tag("details", properties);
+var tagDfn = (properties) => tag("dfn", properties);
+var tagDialog = (properties) => tag("dialog", properties);
+var tagDiv = (properties) => tag("div", properties);
+var tagDl = (properties) => tag("dl", properties);
+var tagDt = (properties) => tag("dt", properties);
+var tagEm = (properties) => tag("em", properties);
+var tagEmbed = (properties) => tag("embed", properties);
+var tagFieldset = (properties) => tag("fieldset", properties);
+var tagFigcaption = (properties) => tag("figcaption", properties);
+var tagFigure = (properties) => tag("figure", properties);
+var tagFooter = (properties) => tag("footer", properties);
+var tagForm = (properties) => tag("form", properties);
+var tagH1 = (properties) => tag("h1", properties);
+var tagH2 = (properties) => tag("h2", properties);
+var tagH3 = (properties) => tag("h3", properties);
+var tagH4 = (properties) => tag("h4", properties);
+var tagH5 = (properties) => tag("h5", properties);
+var tagH6 = (properties) => tag("h6", properties);
+var tagHead = (properties) => tag("head", properties);
+var tagHeader = (properties) => tag("header", properties);
+var tagHgroup = (properties) => tag("hgroup", properties);
+var tagHr = (properties) => tag("hr", properties);
+var tagHtml = (properties) => tag("html", properties);
+var tagI = (properties) => tag("i", properties);
+var tagIframe = (properties) => tag("iframe", properties);
+var tagImg = (properties) => tag("img", properties);
+var tagInput = (properties) => tag("input", properties);
+var tagIns = (properties) => tag("ins", properties);
+var tagKbd = (properties) => tag("kbd", properties);
+var tagLabel = (properties) => tag("label", properties);
+var tagLegend = (properties) => tag("legend", properties);
+var tagLi = (properties) => tag("li", properties);
+var tagLink = (properties) => tag("link", properties);
+var tagMain = (properties) => tag("main", properties);
+var tagMap = (properties) => tag("map", properties);
+var tagMark = (properties) => tag("mark", properties);
+var tagMenu = (properties) => tag("menu", properties);
+var tagMeta = (properties) => tag("meta", properties);
+var tagMeter = (properties) => tag("meter", properties);
+var tagNav = (properties) => tag("nav", properties);
+var tagNoscript = (properties) => tag("noscript", properties);
+var tagObject = (properties) => tag("object", properties);
+var tagOl = (properties) => tag("ol", properties);
+var tagOptgroup = (properties) => tag("optgroup", properties);
+var tagOption = (properties) => tag("option", properties);
+var tagOutput = (properties) => tag("output", properties);
+var tagP = (properties) => tag("p", properties);
+var tagPicture = (properties) => tag("picture", properties);
+var tagPre = (properties) => tag("pre", properties);
+var tagProgress = (properties) => tag("progress", properties);
+var tagQ = (properties) => tag("q", properties);
+var tagRp = (properties) => tag("rp", properties);
+var tagRt = (properties) => tag("rt", properties);
+var tagRuby = (properties) => tag("ruby", properties);
+var tagS = (properties) => tag("s", properties);
+var tagSamp = (properties) => tag("samp", properties);
+var tagScript = (properties) => tag("script", properties);
+var tagSearch = (properties) => tag("search", properties);
+var tagSection = (properties) => tag("section", properties);
+var tagSelect = (properties) => tag("select", properties);
+var tagSlot = (properties) => tag("slot", properties);
+var tagSmall = (properties) => tag("small", properties);
+var tagSource = (properties) => tag("source", properties);
+var tagSpan = (properties) => tag("span", properties);
+var tagStrong = (properties) => tag("strong", properties);
+var tagStyle = (properties) => tag("style", properties);
+var tagSub = (properties) => tag("sub", properties);
+var tagSummary = (properties) => tag("summary", properties);
+var tagSup = (properties) => tag("sup", properties);
+var tagTable = (properties) => tag("table", properties);
+var tagTbody = (properties) => tag("tbody", properties);
+var tagTd = (properties) => tag("td", properties);
+var tagTemplate = (properties) => tag("template", properties);
+var tagTextarea = (properties) => tag("textarea", properties);
+var tagTfoot = (properties) => tag("tfoot", properties);
+var tagTh = (properties) => tag("th", properties);
+var tagThead = (properties) => tag("thead", properties);
+var tagTime = (properties) => tag("time", properties);
+var tagTitle = (properties) => tag("title", properties);
+var tagTr = (properties) => tag("tr", properties);
+var tagTrack = (properties) => tag("track", properties);
+var tagU = (properties) => tag("u", properties);
+var tagUl = (properties) => tag("ul", properties);
+var tagVar = (properties) => tag("var", properties);
+var tagVideo = (properties) => tag("video", properties);
+var tagWbr = (properties) => tag("wbr", properties);
+
+// src/css/variables/css-namespace.ts
+var sel = {
+  root,
+  all,
+  tag,
+  rule,
+  media,
+  keyframes,
+  ...tag_dsl_generated_exports
+};
+export {
+  ARIA_ATTRIBUTE_KEYS,
+  Alignment,
+  AppDocument,
+  AppSlot,
+  BOOLEAN_ATTRIBUTE_KEYS,
+  BUTTON_TYPES,
+  BaseAttributeBuilder,
+  Breakpoints,
+  Button,
+  ButtonAttributeBuilder,
+  CSSAnimation,
+  CSSBackground,
+  CSSBorder,
+  CSSColor,
+  CSSColorName,
+  CSSFlex,
+  CSSFont,
+  CSSGrid,
+  CSSList,
+  CSSPropertyKey,
+  CSSSpacing,
+  CSSTable,
+  CSSText,
+  CSSTransform,
+  CSSVisibility,
+  CSSVisual,
+  CssConfig,
+  CssManager,
+  CssPositionMaker,
+  CssStyleManager,
+  DefaultCssManager,
+  DraftOleError,
+  DuplicateCssPropertyError,
+  ExportableError,
+  FileExporter,
+  FormAttributeBuilder,
+  HStack,
+  HTMLFormatter,
+  Heading,
+  HtmlAttribute,
+  HtmlStyle,
+  HtmlTag,
+  INPUT_TYPES,
+  Image,
+  ImageAttributeBuilder,
+  InputAttributeBuilder,
+  JQUERY_METHOD_TYPES,
+  JQueryHelper,
+  JQueryManager,
+  KEY_VALUE_ATTRIBUTE_KEYS,
+  LazyLayoutManager,
+  Link,
+  LinkAttributeBuilder,
+  PageDocument,
+  PairType,
+  PseudoStyleBuilder,
+  SELF_CLOSING_TAGS,
+  Section,
+  SelfClosingType,
+  Spacer,
+  TAG_TYPES,
+  Text,
+  TextType,
+  VStack,
+  Text2 as ViewText,
+  ZStackAlignment,
+  __draftole_label__,
+  a,
+  abbr,
+  address,
+  app,
+  area,
+  article,
+  aside,
+  audio,
+  b,
+  base,
+  blockquote,
+  body,
+  br,
+  button,
+  canvas,
+  caption,
+  cite,
+  code,
+  col,
+  colgroup,
+  createBooleanValue,
+  createCustomValue,
+  createKeyValueValue,
+  createVanillaScript,
+  css,
+  datalist,
+  dd,
+  details,
+  dialog,
+  div,
+  divider,
+  djb2Hash,
+  dl,
+  dt,
+  tags as el,
+  em,
+  embed,
+  emitHandler,
+  escapeHtml,
+  fieldset,
+  figcaption,
+  figure,
+  footer,
+  form,
+  generateScopedClassName,
+  getTagStructure,
+  guardDuplicateCssProperty,
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6,
+  head,
+  header,
+  hlUnitToCssString,
+  hr,
+  hstack,
+  html,
+  i,
+  iframe,
+  img,
+  input,
+  isJsParam,
+  jsTemplate,
+  kbd,
+  keyframes,
+  label,
+  legend,
+  li,
+  link,
+  main,
+  mark,
+  media,
+  meta,
+  nav,
+  normalizeClassNames,
+  noscript,
+  ol,
+  optgroup,
+  option,
+  output,
+  p,
+  page,
+  param,
+  picture,
+  pre,
+  q,
+  ref,
+  s,
+  samp,
+  script,
+  section,
+  sel,
+  select,
+  small,
+  source,
+  spacer,
+  span,
+  strong,
+  sub,
+  summary,
+  sup,
+  svg,
+  table,
+  tags,
+  tbody,
+  td,
+  textarea,
+  tfoot,
+  th,
+  thead,
+  time,
+  title,
+  tr,
+  track,
+  u,
+  ul,
+  varTag,
+  video,
+  vstack,
+  wbr,
+  wrapDOMReady,
+  zstack
+};
+//# sourceMappingURL=index.js.map