@mikedown/web-component 0.0.0-stage → 0.3.0

package/dist/chunk-WZVZGW65.js

@@ -0,0 +1,684 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/element.ts
+import { bindMikeDownValue } from "@mikedown/core";
+
+// src/hooks.ts
+var connectHook = null;
+function runConnectHook(element) {
+  connectHook?.(element);
+}
+var styledTags = /* @__PURE__ */ new WeakMap();
+function ensureDisplayStyle(doc, tag) {
+  let tags = styledTags.get(doc);
+  if (!tags) {
+    tags = /* @__PURE__ */ new Set();
+    styledTags.set(doc, tags);
+  }
+  if (tags.has(tag)) {
+    return;
+  }
+  tags.add(tag);
+  const css = `:where(${tag}) { display: block; }`;
+  const view = doc.defaultView;
+  try {
+    if (view && "adoptedStyleSheets" in doc && typeof view.CSSStyleSheet?.prototype.replaceSync === "function") {
+      const sheet = new view.CSSStyleSheet();
+      sheet.replaceSync(css);
+      doc.adoptedStyleSheets = [...doc.adoptedStyleSheets, sheet];
+      return;
+    }
+  } catch {
+  }
+  const style = doc.createElement("style");
+  style.setAttribute("data-mikedown-element", tag);
+  style.textContent = css;
+  doc.head.appendChild(style);
+}
+
+// src/element.ts
+var OBSERVED = [
+  "value",
+  "theme",
+  "readonly",
+  "disabled",
+  "placeholder",
+  "name",
+  "required",
+  "min-height",
+  "dark-selector",
+  "spellcheck-dictionary-url",
+  "features",
+  "debounce",
+  "aria-label",
+  "aria-labelledby"
+];
+var REBUILD_ON = /* @__PURE__ */ new Set(["placeholder", "spellcheck-dictionary-url", "features", "dark-selector", "debounce", "aria-label", "aria-labelledby"]);
+var UPGRADE_PROPS = [
+  "value",
+  "defaultValue",
+  "theme",
+  "readOnly",
+  "disabled",
+  "placeholder",
+  "name",
+  "required",
+  "minHeight",
+  "darkSelector",
+  "spellcheckDictionaryUrl",
+  "features",
+  "settings",
+  "host"
+];
+var VALUE_MISSING_MESSAGE = "Please fill out this field.";
+var Base = typeof HTMLElement === "undefined" ? class {
+} : HTMLElement;
+function dedentScriptText(text) {
+  const lines = text.replace(/^\r?\n/, "").replace(/\s+$/, "").split(/\r?\n/);
+  const indents = lines.filter((l) => l.trim()).map((l) => /^[ \t]*/.exec(l)[0].length);
+  const cut = indents.length ? Math.min(...indents) : 0;
+  return lines.map((l) => l.slice(cut)).join("\n") + (lines.length && lines.some((l) => l.trim()) ? "\n" : "");
+}
+function parseTheme(value) {
+  return value === "light" || value === "dark" ? value : "auto";
+}
+var _internals, _binding, _value, _defaultValue, _valueSetByProperty, _initialized, _featuresAttrCache, _settings, _host, _ai, _formDisabled, _rebuildQueued, _fallbackInput, _fallbackForm, _MikeDownElement_instances, upgradeProperty_fn, readInitialValue_fn, create_fn, destroy_fn, scheduleRebuild_fn, setValue_fn, accessibleName_fn, isDisabled_fn, applyDisabled_fn, applyMinHeight_fn, setOrRemove_fn, hasFormInternals_fn, valueMissing_fn, syncForm_fn, syncValidity_fn, attachFallbackForm_fn, detachFallbackForm_fn, _onFallbackReset;
+var MikeDownElement = class extends Base {
+  constructor() {
+    super();
+    __privateAdd(this, _MikeDownElement_instances);
+    __privateAdd(this, _internals);
+    __privateAdd(this, _binding, null);
+    /** Current value: the last text the editor reported, or the last one set. */
+    __privateAdd(this, _value, "");
+    /** Reset target: the `value` attribute, else the child source's text at first connect. */
+    __privateAdd(this, _defaultValue, "");
+    __privateAdd(this, _valueSetByProperty, false);
+    __privateAdd(this, _initialized, false);
+    __privateAdd(this, _featuresAttrCache, { raw: null, parsed: null });
+    __privateAdd(this, _settings, {});
+    __privateAdd(this, _host, {});
+    __privateAdd(this, _ai);
+    __privateAdd(this, _formDisabled, false);
+    __privateAdd(this, _rebuildQueued, false);
+    __privateAdd(this, _fallbackInput, null);
+    __privateAdd(this, _fallbackForm, null);
+    __privateAdd(this, _onFallbackReset, () => {
+      this.formResetCallback();
+    });
+    let internals = null;
+    try {
+      internals = typeof this.attachInternals === "function" ? this.attachInternals() : null;
+    } catch {
+      internals = null;
+    }
+    __privateSet(this, _internals, internals);
+    this.addEventListener("click", (event) => {
+      if (event.target !== this) {
+        return;
+      }
+      const active = this.ownerDocument.activeElement;
+      if (active && this.contains(active)) {
+        return;
+      }
+      this.focus();
+    });
+    this.addEventListener("change", (event) => {
+      if (event.target !== this) {
+        event.stopImmediatePropagation();
+      }
+    });
+  }
+  static get observedAttributes() {
+    return [...OBSERVED];
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────────────
+  connectedCallback() {
+    if (!__privateGet(this, _initialized)) {
+      __privateSet(this, _initialized, true);
+      for (const prop of UPGRADE_PROPS) {
+        __privateMethod(this, _MikeDownElement_instances, upgradeProperty_fn).call(this, prop);
+      }
+      __privateMethod(this, _MikeDownElement_instances, readInitialValue_fn).call(this);
+    }
+    ensureDisplayStyle(this.ownerDocument, this.localName);
+    __privateMethod(this, _MikeDownElement_instances, applyMinHeight_fn).call(this);
+    __privateMethod(this, _MikeDownElement_instances, attachFallbackForm_fn).call(this);
+    runConnectHook(this);
+    __privateMethod(this, _MikeDownElement_instances, create_fn).call(this);
+  }
+  disconnectedCallback() {
+    __privateMethod(this, _MikeDownElement_instances, destroy_fn).call(this);
+    __privateMethod(this, _MikeDownElement_instances, detachFallbackForm_fn).call(this);
+  }
+  attributeChangedCallback(name, oldValue, newValue) {
+    if (oldValue === newValue) {
+      return;
+    }
+    switch (name) {
+      case "value":
+        __privateSet(this, _defaultValue, newValue ?? "");
+        if (__privateGet(this, _initialized)) {
+          __privateMethod(this, _MikeDownElement_instances, setValue_fn).call(this, newValue ?? "");
+        }
+        break;
+      case "theme":
+        __privateGet(this, _binding)?.setTheme(parseTheme(newValue));
+        break;
+      case "readonly":
+        __privateGet(this, _binding)?.setReadOnly(newValue !== null);
+        break;
+      case "disabled":
+        __privateMethod(this, _MikeDownElement_instances, applyDisabled_fn).call(this);
+        break;
+      case "required":
+        __privateMethod(this, _MikeDownElement_instances, syncValidity_fn).call(this);
+        break;
+      case "name":
+        if (__privateGet(this, _fallbackInput)) {
+          __privateGet(this, _fallbackInput).name = newValue ?? "";
+        }
+        break;
+      case "min-height":
+        __privateMethod(this, _MikeDownElement_instances, applyMinHeight_fn).call(this);
+        break;
+      default:
+        if (REBUILD_ON.has(name)) {
+          __privateMethod(this, _MikeDownElement_instances, scheduleRebuild_fn).call(this);
+        }
+    }
+  }
+  // ── Form-associated callbacks ─────────────────────────────────────────────
+  formResetCallback() {
+    __privateMethod(this, _MikeDownElement_instances, setValue_fn).call(this, __privateGet(this, _defaultValue));
+    __privateSet(this, _valueSetByProperty, false);
+  }
+  formDisabledCallback(disabled) {
+    __privateSet(this, _formDisabled, disabled);
+    __privateMethod(this, _MikeDownElement_instances, applyDisabled_fn).call(this);
+  }
+  formStateRestoreCallback(state) {
+    if (typeof state === "string") {
+      __privateMethod(this, _MikeDownElement_instances, setValue_fn).call(this, state);
+    }
+  }
+  // ── Value ─────────────────────────────────────────────────────────────────
+  /** The markdown. Setting it loads the text as the pristine baseline and fires no `change`. */
+  get value() {
+    return __privateGet(this, _value);
+  }
+  set value(markdown) {
+    __privateSet(this, _valueSetByProperty, true);
+    __privateMethod(this, _MikeDownElement_instances, setValue_fn).call(this, markdown == null ? "" : String(markdown));
+  }
+  /** The `value` attribute: the initial value and the target of a form reset. */
+  get defaultValue() {
+    return this.getAttribute("value") ?? __privateGet(this, _defaultValue);
+  }
+  set defaultValue(markdown) {
+    this.setAttribute("value", markdown == null ? "" : String(markdown));
+  }
+  // ── Reflected attributes ──────────────────────────────────────────────────
+  get theme() {
+    return parseTheme(this.getAttribute("theme"));
+  }
+  set theme(theme) {
+    this.setAttribute("theme", parseTheme(theme));
+  }
+  get readOnly() {
+    return this.hasAttribute("readonly");
+  }
+  set readOnly(on) {
+    this.toggleAttribute("readonly", !!on);
+  }
+  get disabled() {
+    return this.hasAttribute("disabled");
+  }
+  set disabled(on) {
+    this.toggleAttribute("disabled", !!on);
+  }
+  get required() {
+    return this.hasAttribute("required");
+  }
+  set required(on) {
+    this.toggleAttribute("required", !!on);
+  }
+  get placeholder() {
+    return this.getAttribute("placeholder") ?? "";
+  }
+  set placeholder(text) {
+    __privateMethod(this, _MikeDownElement_instances, setOrRemove_fn).call(this, "placeholder", text);
+  }
+  get name() {
+    return this.getAttribute("name") ?? "";
+  }
+  set name(name) {
+    __privateMethod(this, _MikeDownElement_instances, setOrRemove_fn).call(this, "name", name);
+  }
+  /** CSS length for the editor's minimum height (`--mikedown-min-height`). Default 240px. */
+  get minHeight() {
+    return this.getAttribute("min-height") ?? "";
+  }
+  set minHeight(value) {
+    __privateMethod(this, _MikeDownElement_instances, setOrRemove_fn).call(this, "min-height", value);
+  }
+  /** With `theme="auto"`: dark when `element.closest(selector)` matches, else light. */
+  get darkSelector() {
+    return this.getAttribute("dark-selector") ?? "";
+  }
+  set darkSelector(selector) {
+    __privateMethod(this, _MikeDownElement_instances, setOrRemove_fn).call(this, "dark-selector", selector);
+  }
+  /** Folder base of the spell-check dictionaries (core appends `/en/` or `/en-GB/`). */
+  get spellcheckDictionaryUrl() {
+    return this.getAttribute("spellcheck-dictionary-url") ?? "";
+  }
+  set spellcheckDictionaryUrl(url) {
+    __privateMethod(this, _MikeDownElement_instances, setOrRemove_fn).call(this, "spellcheck-dictionary-url", url);
+  }
+  /** Milliseconds of quiet before `change` fires. Default 150. */
+  get debounce() {
+    const n = Number(this.getAttribute("debounce"));
+    return this.hasAttribute("debounce") && Number.isFinite(n) && n >= 0 ? n : 150;
+  }
+  set debounce(ms) {
+    this.setAttribute("debounce", String(ms));
+  }
+  /** Feature switches. The `features` attribute takes the same object as JSON. Changing them rebuilds the editor. */
+  get features() {
+    const raw = this.getAttribute("features");
+    if (raw !== __privateGet(this, _featuresAttrCache).raw) {
+      let parsed = null;
+      if (raw) {
+        try {
+          const json = JSON.parse(raw);
+          if (json && typeof json === "object" && !Array.isArray(json)) {
+            parsed = json;
+          } else {
+            console.warn("<mikedown-editor>: the features attribute must be a JSON object.");
+          }
+        } catch {
+          console.warn("<mikedown-editor>: the features attribute is not valid JSON.");
+        }
+      }
+      __privateSet(this, _featuresAttrCache, { raw, parsed });
+    }
+    return { ...__privateGet(this, _featuresAttrCache).parsed ?? {} };
+  }
+  set features(features) {
+    if (features) {
+      this.setAttribute("features", JSON.stringify(features));
+    } else {
+      this.removeAttribute("features");
+    }
+  }
+  // ── Properties only ───────────────────────────────────────────────────────
+  /** Core settings (fonts, content width, ...). Applied live through `handle.updateSettings`. */
+  get settings() {
+    return { ...__privateGet(this, _settings) };
+  }
+  set settings(settings) {
+    __privateSet(this, _settings, { ...settings ?? {} });
+    __privateGet(this, _binding)?.handle.updateSettings(__privateGet(this, _settings));
+  }
+  /**
+   * Host methods (`uploadImage`, `openLink`, `resolveImageSrc`, ...). Core turns a
+   * feature on only when its method is present, so a change rebuilds the editor.
+   */
+  get host() {
+    return __privateGet(this, _host);
+  }
+  set host(host) {
+    __privateSet(this, _host, host ?? {});
+    __privateMethod(this, _MikeDownElement_instances, scheduleRebuild_fn).call(this);
+  }
+  /**
+   * The AI host group (`complete`, and for tier 2 `listEngines`, `testEngine`, ...). A property only: it holds
+   * functions, so there is no attribute. Wins over `host.ai`. Core turns the AI features on when it is present,
+   * so a change rebuilds the editor. Core ships no provider SDK; the page supplies the transport.
+   */
+  get ai() {
+    return __privateGet(this, _ai) ?? __privateGet(this, _host).ai;
+  }
+  set ai(ai) {
+    __privateSet(this, _ai, ai ?? void 0);
+    __privateMethod(this, _MikeDownElement_instances, scheduleRebuild_fn).call(this);
+  }
+  /** The editor handle while connected, else null. */
+  get handle() {
+    return __privateGet(this, _binding)?.handle ?? null;
+  }
+  // ── Form and validity ─────────────────────────────────────────────────────
+  get form() {
+    return __privateGet(this, _internals) && "form" in __privateGet(this, _internals) ? __privateGet(this, _internals).form : this.closest("form");
+  }
+  get labels() {
+    return __privateGet(this, _internals)?.labels ?? [];
+  }
+  get type() {
+    return this.localName;
+  }
+  get validity() {
+    if (__privateMethod(this, _MikeDownElement_instances, hasFormInternals_fn).call(this)) {
+      return __privateGet(this, _internals).validity;
+    }
+    const valueMissing = __privateMethod(this, _MikeDownElement_instances, valueMissing_fn).call(this);
+    return { valueMissing, valid: !valueMissing };
+  }
+  get validationMessage() {
+    if (__privateMethod(this, _MikeDownElement_instances, hasFormInternals_fn).call(this)) {
+      return __privateGet(this, _internals).validationMessage;
+    }
+    return __privateMethod(this, _MikeDownElement_instances, valueMissing_fn).call(this) ? VALUE_MISSING_MESSAGE : "";
+  }
+  get willValidate() {
+    if (__privateMethod(this, _MikeDownElement_instances, hasFormInternals_fn).call(this)) {
+      return __privateGet(this, _internals).willValidate;
+    }
+    return !__privateMethod(this, _MikeDownElement_instances, isDisabled_fn).call(this) && !this.readOnly;
+  }
+  checkValidity() {
+    if (__privateMethod(this, _MikeDownElement_instances, hasFormInternals_fn).call(this)) {
+      return __privateGet(this, _internals).checkValidity();
+    }
+    if (!this.willValidate || !__privateMethod(this, _MikeDownElement_instances, valueMissing_fn).call(this)) {
+      return true;
+    }
+    this.dispatchEvent(new Event("invalid", { cancelable: true }));
+    return false;
+  }
+  reportValidity() {
+    if (__privateMethod(this, _MikeDownElement_instances, hasFormInternals_fn).call(this)) {
+      return __privateGet(this, _internals).reportValidity();
+    }
+    const ok = this.checkValidity();
+    if (!ok) {
+      this.focus();
+    }
+    return ok;
+  }
+  /** Focus the editable surface. */
+  focus(options) {
+    if (__privateGet(this, _binding)) {
+      __privateGet(this, _binding).focus();
+    } else {
+      super.focus(options);
+    }
+  }
+};
+_internals = new WeakMap();
+_binding = new WeakMap();
+_value = new WeakMap();
+_defaultValue = new WeakMap();
+_valueSetByProperty = new WeakMap();
+_initialized = new WeakMap();
+_featuresAttrCache = new WeakMap();
+_settings = new WeakMap();
+_host = new WeakMap();
+_ai = new WeakMap();
+_formDisabled = new WeakMap();
+_rebuildQueued = new WeakMap();
+_fallbackInput = new WeakMap();
+_fallbackForm = new WeakMap();
+_MikeDownElement_instances = new WeakSet();
+// ── Internals ─────────────────────────────────────────────────────────────
+upgradeProperty_fn = function(prop) {
+  if (Object.prototype.hasOwnProperty.call(this, prop)) {
+    const value = this[prop];
+    delete this[prop];
+    this[prop] = value;
+  }
+};
+/** `value` attribute, else a child <textarea> or <script type="text/markdown">, which is then hidden. */
+readInitialValue_fn = function() {
+  const source = this.querySelector(
+    ':scope > textarea, :scope > script[type="text/markdown"]'
+  );
+  let sourceText = null;
+  if (source && source.localName === "textarea") {
+    const textarea = source;
+    sourceText = textarea.value;
+    if (!this.hasAttribute("name") && textarea.name) {
+      this.setAttribute("name", textarea.name);
+    }
+    if (!this.hasAttribute("required") && textarea.required) {
+      this.setAttribute("required", "");
+    }
+    if (!this.hasAttribute("placeholder") && textarea.placeholder) {
+      this.setAttribute("placeholder", textarea.placeholder);
+    }
+    textarea.hidden = true;
+    textarea.style.display = "none";
+    textarea.disabled = true;
+    textarea.setAttribute("aria-hidden", "true");
+  } else if (source) {
+    sourceText = dedentScriptText(source.textContent ?? "");
+  }
+  const attr = this.getAttribute("value");
+  __privateSet(this, _defaultValue, attr ?? sourceText ?? "");
+  if (!__privateGet(this, _valueSetByProperty)) {
+    __privateSet(this, _value, __privateGet(this, _defaultValue));
+  }
+};
+create_fn = function() {
+  if (__privateGet(this, _binding) || !this.isConnected) {
+    return;
+  }
+  const { ariaLabel, ariaLabelledBy } = __privateMethod(this, _MikeDownElement_instances, accessibleName_fn).call(this);
+  const userHost = __privateGet(this, _host);
+  const ai = __privateGet(this, _ai) ?? userHost.ai;
+  const binding = bindMikeDownValue(this, {
+    initialValue: __privateGet(this, _value),
+    debounceMs: this.debounce,
+    theme: this.theme,
+    darkSelector: this.darkSelector || void 0,
+    readOnly: this.readOnly,
+    disabled: __privateMethod(this, _MikeDownElement_instances, isDisabled_fn).call(this),
+    placeholder: this.getAttribute("placeholder") ?? void 0,
+    spellcheckDictionaryUrl: this.spellcheckDictionaryUrl || void 0,
+    features: this.features,
+    settings: __privateGet(this, _settings),
+    ariaLabel,
+    ariaLabelledBy,
+    host: {
+      ...userHost,
+      ...ai ? { ai } : {},
+      // Every keystroke keeps `value`, the form value and validity current;
+      // the debounced `change` event comes from onValue below.
+      onChange: (markdown, meta) => {
+        userHost.onChange?.(markdown, meta);
+        __privateSet(this, _value, markdown);
+        __privateMethod(this, _MikeDownElement_instances, syncForm_fn).call(this);
+      }
+    },
+    onValue: (markdown) => {
+      __privateSet(this, _value, markdown);
+      __privateMethod(this, _MikeDownElement_instances, syncForm_fn).call(this);
+      this.dispatchEvent(
+        new CustomEvent("change", { detail: { value: markdown }, bubbles: true, composed: true })
+      );
+    }
+  });
+  __privateSet(this, _binding, binding);
+  __privateMethod(this, _MikeDownElement_instances, syncForm_fn).call(this);
+  queueMicrotask(() => {
+    if (__privateGet(this, _binding) !== binding) {
+      return;
+    }
+    this.dispatchEvent(
+      new CustomEvent("ready", { detail: { handle: binding.handle }, bubbles: true, composed: true })
+    );
+  });
+};
+destroy_fn = function() {
+  const binding = __privateGet(this, _binding);
+  if (!binding) {
+    return;
+  }
+  binding.destroy();
+  __privateSet(this, _binding, null);
+};
+scheduleRebuild_fn = function() {
+  if (!__privateGet(this, _binding) || __privateGet(this, _rebuildQueued)) {
+    return;
+  }
+  __privateSet(this, _rebuildQueued, true);
+  queueMicrotask(() => {
+    __privateSet(this, _rebuildQueued, false);
+    if (!__privateGet(this, _binding) || !this.isConnected) {
+      return;
+    }
+    const hadFocus = this.contains(this.ownerDocument.activeElement);
+    __privateMethod(this, _MikeDownElement_instances, destroy_fn).call(this);
+    __privateMethod(this, _MikeDownElement_instances, create_fn).call(this);
+    if (hadFocus) {
+      __privateGet(this, _binding)?.focus();
+    }
+  });
+};
+setValue_fn = function(markdown) {
+  __privateSet(this, _value, markdown);
+  __privateGet(this, _binding)?.setValue(markdown);
+  __privateMethod(this, _MikeDownElement_instances, syncForm_fn).call(this);
+};
+accessibleName_fn = function() {
+  const labelledBy = this.getAttribute("aria-labelledby");
+  if (labelledBy) {
+    return { ariaLabelledBy: labelledBy };
+  }
+  const label = this.getAttribute("aria-label");
+  if (label) {
+    return { ariaLabel: label };
+  }
+  const labels = Array.from(__privateGet(this, _internals)?.labels ?? []);
+  if (!labels.length) {
+    return {};
+  }
+  const ids = labels.map((el, i) => {
+    if (!el.id) {
+      el.id = `${this.id || "mikedown-editor"}-label${labels.length > 1 ? `-${i + 1}` : ""}`;
+    }
+    return el.id;
+  });
+  return { ariaLabelledBy: ids.join(" ") };
+};
+isDisabled_fn = function() {
+  return this.hasAttribute("disabled") || __privateGet(this, _formDisabled);
+};
+applyDisabled_fn = function() {
+  __privateGet(this, _binding)?.setDisabled(__privateMethod(this, _MikeDownElement_instances, isDisabled_fn).call(this));
+  if (__privateGet(this, _fallbackInput)) {
+    __privateGet(this, _fallbackInput).disabled = __privateMethod(this, _MikeDownElement_instances, isDisabled_fn).call(this);
+  }
+  __privateMethod(this, _MikeDownElement_instances, syncValidity_fn).call(this);
+};
+applyMinHeight_fn = function() {
+  const value = this.getAttribute("min-height");
+  if (value) {
+    this.style.setProperty("--mikedown-min-height", /^\d+(\.\d+)?$/.test(value) ? `${value}px` : value);
+  } else {
+    this.style.removeProperty("--mikedown-min-height");
+  }
+};
+setOrRemove_fn = function(attr, value) {
+  if (value == null || value === "") {
+    this.removeAttribute(attr);
+  } else {
+    this.setAttribute(attr, String(value));
+  }
+};
+hasFormInternals_fn = function() {
+  return !!__privateGet(this, _internals) && typeof __privateGet(this, _internals).setFormValue === "function";
+};
+valueMissing_fn = function() {
+  return this.required && !__privateMethod(this, _MikeDownElement_instances, isDisabled_fn).call(this) && __privateGet(this, _value).trim() === "";
+};
+syncForm_fn = function() {
+  if (__privateMethod(this, _MikeDownElement_instances, hasFormInternals_fn).call(this)) {
+    __privateGet(this, _internals).setFormValue(__privateGet(this, _value), __privateGet(this, _value));
+  } else if (__privateGet(this, _fallbackInput)) {
+    __privateGet(this, _fallbackInput).value = __privateGet(this, _value);
+  }
+  __privateMethod(this, _MikeDownElement_instances, syncValidity_fn).call(this);
+};
+syncValidity_fn = function() {
+  if (!__privateMethod(this, _MikeDownElement_instances, hasFormInternals_fn).call(this) || typeof __privateGet(this, _internals).setValidity !== "function") {
+    return;
+  }
+  if (__privateMethod(this, _MikeDownElement_instances, valueMissing_fn).call(this)) {
+    const anchor = this.querySelector(".ProseMirror") ?? void 0;
+    __privateGet(this, _internals).setValidity({ valueMissing: true }, VALUE_MISSING_MESSAGE, anchor);
+  } else {
+    __privateGet(this, _internals).setValidity({});
+  }
+};
+/**
+ * Without ElementInternals form support (jsdom, very old browsers) a hidden
+ * <input> carries the value, and the form's reset event resets it.
+ */
+attachFallbackForm_fn = function() {
+  if (__privateMethod(this, _MikeDownElement_instances, hasFormInternals_fn).call(this)) {
+    return;
+  }
+  if (!__privateGet(this, _fallbackInput)) {
+    const input = this.ownerDocument.createElement("input");
+    input.type = "hidden";
+    input.setAttribute("data-mikedown-form-value", "");
+    __privateSet(this, _fallbackInput, input);
+  }
+  __privateGet(this, _fallbackInput).name = this.name;
+  __privateGet(this, _fallbackInput).disabled = __privateMethod(this, _MikeDownElement_instances, isDisabled_fn).call(this);
+  __privateGet(this, _fallbackInput).value = __privateGet(this, _value);
+  if (__privateGet(this, _fallbackInput).parentNode !== this) {
+    this.appendChild(__privateGet(this, _fallbackInput));
+  }
+  const form = this.closest("form");
+  if (form !== __privateGet(this, _fallbackForm)) {
+    __privateGet(this, _fallbackForm)?.removeEventListener("reset", __privateGet(this, _onFallbackReset));
+    form?.addEventListener("reset", __privateGet(this, _onFallbackReset));
+    __privateSet(this, _fallbackForm, form);
+  }
+};
+detachFallbackForm_fn = function() {
+  __privateGet(this, _fallbackForm)?.removeEventListener("reset", __privateGet(this, _onFallbackReset));
+  __privateSet(this, _fallbackForm, null);
+};
+_onFallbackReset = new WeakMap();
+MikeDownElement.formAssociated = true;
+
+// src/index.ts
+var DEFAULT_TAG = "mikedown-editor";
+function defineMikeDownElement(tag = DEFAULT_TAG) {
+  if (typeof customElements === "undefined") {
+    return MikeDownElement;
+  }
+  const existing = customElements.get(tag);
+  if (existing) {
+    return existing;
+  }
+  const registry = customElements;
+  const baseTaken = baseDefined || !!registry.getName?.(MikeDownElement);
+  const ctor = baseTaken ? class extends MikeDownElement {
+  } : MikeDownElement;
+  customElements.define(tag, ctor);
+  if (ctor === MikeDownElement) {
+    baseDefined = true;
+  }
+  return ctor;
+}
+var baseDefined = false;
+
+export {
+  dedentScriptText,
+  MikeDownElement,
+  DEFAULT_TAG,
+  defineMikeDownElement
+};
+//# sourceMappingURL=chunk-WZVZGW65.js.map