@oktis-works/admin 0.1.0

package/dist/server/chunks/pages/edit_DSkfb6lH.mjs

@@ -0,0 +1,2173 @@
+import { e as createComponent$1, k as renderComponent, r as renderTemplate, m as maybeRenderHead } from '../astro_C5DJOQ1V.mjs';
+import { $ as $$DashboardLayout } from './index_7XvpCth_.mjs';
+import { ssr, ssrHydrationKey, escape, createComponent, ssrAttribute, memo } from 'solid-js/web';
+import { createSignal, createMemo, Show, For, onMount } from 'solid-js';
+import { a as apiClient } from './post-types_BeBr92jW.mjs';
+/* empty css                         */
+
+function validateFieldClient(_field, _value) {
+  return { valid: true, errors: [] };
+}
+function expandCloneFields(fields) {
+  return fields;
+}
+
+var re$2 = {exports: {}};
+
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+const SEMVER_SPEC_VERSION = '2.0.0';
+
+const MAX_LENGTH$1 = 256;
+const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER ||
+/* istanbul ignore next */ 9007199254740991;
+
+// Max safe segment length for coercion.
+const MAX_SAFE_COMPONENT_LENGTH = 16;
+
+// Max safe length for a build identifier. The max length minus 6 characters for
+// the shortest version with a build 0.0.0+BUILD.
+const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH$1 - 6;
+
+const RELEASE_TYPES = [
+  'major',
+  'premajor',
+  'minor',
+  'preminor',
+  'patch',
+  'prepatch',
+  'prerelease',
+];
+
+var constants$1 = {
+  MAX_LENGTH: MAX_LENGTH$1,
+  MAX_SAFE_COMPONENT_LENGTH,
+  MAX_SAFE_BUILD_LENGTH,
+  MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
+  RELEASE_TYPES,
+  SEMVER_SPEC_VERSION,
+  FLAG_INCLUDE_PRERELEASE: 0b001,
+  FLAG_LOOSE: 0b010,
+};
+
+const debug$1 = (
+  typeof process === 'object' &&
+  process.env &&
+  process.env.NODE_DEBUG &&
+  /\bsemver\b/i.test(process.env.NODE_DEBUG)
+) ? (...args) => console.error('SEMVER', ...args)
+  : () => {};
+
+var debug_1 = debug$1;
+
+(function (module, exports) {
+
+	const {
+	  MAX_SAFE_COMPONENT_LENGTH,
+	  MAX_SAFE_BUILD_LENGTH,
+	  MAX_LENGTH,
+	} = constants$1;
+	const debug = debug_1;
+	exports = module.exports = {};
+
+	// The actual regexps go on exports.re
+	const re = exports.re = [];
+	const safeRe = exports.safeRe = [];
+	const src = exports.src = [];
+	const safeSrc = exports.safeSrc = [];
+	const t = exports.t = {};
+	let R = 0;
+
+	const LETTERDASHNUMBER = '[a-zA-Z0-9-]';
+
+	// Replace some greedy regex tokens to prevent regex dos issues. These regex are
+	// used internally via the safeRe object since all inputs in this library get
+	// normalized first to trim and collapse all extra whitespace. The original
+	// regexes are exported for userland consumption and lower level usage. A
+	// future breaking change could export the safer regex only with a note that
+	// all input should have extra whitespace removed.
+	const safeRegexReplacements = [
+	  ['\\s', 1],
+	  ['\\d', MAX_LENGTH],
+	  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
+	];
+
+	const makeSafeRegex = (value) => {
+	  for (const [token, max] of safeRegexReplacements) {
+	    value = value
+	      .split(`${token}*`).join(`${token}{0,${max}}`)
+	      .split(`${token}+`).join(`${token}{1,${max}}`);
+	  }
+	  return value
+	};
+
+	const createToken = (name, value, isGlobal) => {
+	  const safe = makeSafeRegex(value);
+	  const index = R++;
+	  debug(name, index, value);
+	  t[name] = index;
+	  src[index] = value;
+	  safeSrc[index] = safe;
+	  re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
+	  safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined);
+	};
+
+	// The following Regular Expressions can be used for tokenizing,
+	// validating, and parsing SemVer version strings.
+
+	// ## Numeric Identifier
+	// A single `0`, or a non-zero digit followed by zero or more digits.
+
+	createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
+	createToken('NUMERICIDENTIFIERLOOSE', '\\d+');
+
+	// ## Non-numeric Identifier
+	// Zero or more digits, followed by a letter or hyphen, and then zero or
+	// more letters, digits, or hyphens.
+
+	createToken('NONNUMERICIDENTIFIER', `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+
+	// ## Main Version
+	// Three dot-separated numeric identifiers.
+
+	createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
+	                   `(${src[t.NUMERICIDENTIFIER]})\\.` +
+	                   `(${src[t.NUMERICIDENTIFIER]})`);
+
+	createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+	                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+	                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+
+	// ## Pre-release Version Identifier
+	// A numeric identifier, or a non-numeric identifier.
+	// Non-numeric identifiers include numeric identifiers but can be longer.
+	// Therefore non-numeric identifiers must go first.
+
+	createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NONNUMERICIDENTIFIER]
+	}|${src[t.NUMERICIDENTIFIER]})`);
+
+	createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NONNUMERICIDENTIFIER]
+	}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+
+	// ## Pre-release Version
+	// Hyphen, followed by one or more dot-separated pre-release version
+	// identifiers.
+
+	createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
+	}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+
+	createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
+	}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+
+	// ## Build Metadata Identifier
+	// Any combination of digits, letters, or hyphens.
+
+	createToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`);
+
+	// ## Build Metadata
+	// Plus sign, followed by one or more period-separated build metadata
+	// identifiers.
+
+	createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
+	}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+
+	// ## Full Version String
+	// A main version, followed optionally by a pre-release version and
+	// build metadata.
+
+	// Note that the only major, minor, patch, and pre-release sections of
+	// the version string are capturing groups.  The build metadata is not a
+	// capturing group, because it should not ever be used in version
+	// comparison.
+
+	createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
+	}${src[t.PRERELEASE]}?${
+	  src[t.BUILD]}?`);
+
+	createToken('FULL', `^${src[t.FULLPLAIN]}$`);
+
+	// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+	// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+	// common in the npm registry.
+	createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
+	}${src[t.PRERELEASELOOSE]}?${
+	  src[t.BUILD]}?`);
+
+	createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`);
+
+	createToken('GTLT', '((?:<|>)?=?)');
+
+	// Something like "2.*" or "1.2.x".
+	// Note that "x.x" is a valid xRange identifier, meaning "any version"
+	// Only the first item is strictly required.
+	createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+	createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+
+	createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
+	                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+	                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+	                   `(?:${src[t.PRERELEASE]})?${
+	                     src[t.BUILD]}?` +
+	                   `)?)?`);
+
+	createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+	                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+	                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+	                        `(?:${src[t.PRERELEASELOOSE]})?${
+	                          src[t.BUILD]}?` +
+	                        `)?)?`);
+
+	createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+	createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+
+	// Coercion.
+	// Extract anything that could conceivably be a part of a valid semver
+	createToken('COERCEPLAIN', `${'(^|[^\\d])' +
+	              '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
+	              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+	              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+	createToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+	createToken('COERCEFULL', src[t.COERCEPLAIN] +
+	              `(?:${src[t.PRERELEASE]})?` +
+	              `(?:${src[t.BUILD]})?` +
+	              `(?:$|[^\\d])`);
+	createToken('COERCERTL', src[t.COERCE], true);
+	createToken('COERCERTLFULL', src[t.COERCEFULL], true);
+
+	// Tilde ranges.
+	// Meaning is "reasonably at or greater than"
+	createToken('LONETILDE', '(?:~>?)');
+
+	createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+	exports.tildeTrimReplace = '$1~';
+
+	createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+	createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+
+	// Caret ranges.
+	// Meaning is "at least and backwards compatible with"
+	createToken('LONECARET', '(?:\\^)');
+
+	createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true);
+	exports.caretTrimReplace = '$1^';
+
+	createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+	createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+
+	// A simple gt/lt/eq thing, or just "" to indicate "any version"
+	createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+	createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+
+	// An expression to strip any whitespace between the gtlt and the thing
+	// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+	createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
+	}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+	exports.comparatorTrimReplace = '$1$2$3';
+
+	// Something like `1.2.3 - 1.2.4`
+	// Note that these all use the loose form, because they'll be
+	// checked against either the strict or loose comparator form
+	// later.
+	createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
+	                   `\\s+-\\s+` +
+	                   `(${src[t.XRANGEPLAIN]})` +
+	                   `\\s*$`);
+
+	createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
+	                        `\\s+-\\s+` +
+	                        `(${src[t.XRANGEPLAINLOOSE]})` +
+	                        `\\s*$`);
+
+	// Star ranges basically just allow anything at all.
+	createToken('STAR', '(<|>)?=?\\s*\\*');
+	// >=0.0.0 is like a star
+	createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$');
+	createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$'); 
+} (re$2, re$2.exports));
+
+var reExports = re$2.exports;
+
+// parse out just the options we care about
+const looseOption = Object.freeze({ loose: true });
+const emptyOpts = Object.freeze({ });
+const parseOptions$1 = options => {
+  if (!options) {
+    return emptyOpts
+  }
+
+  if (typeof options !== 'object') {
+    return looseOption
+  }
+
+  return options
+};
+var parseOptions_1 = parseOptions$1;
+
+const numeric = /^[0-9]+$/;
+const compareIdentifiers$1 = (a, b) => {
+  if (typeof a === 'number' && typeof b === 'number') {
+    return a === b ? 0 : a < b ? -1 : 1
+  }
+
+  const anum = numeric.test(a);
+  const bnum = numeric.test(b);
+
+  if (anum && bnum) {
+    a = +a;
+    b = +b;
+  }
+
+  return a === b ? 0
+    : (anum && !bnum) ? -1
+    : (bnum && !anum) ? 1
+    : a < b ? -1
+    : 1
+};
+
+const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
+
+var identifiers$1 = {
+  compareIdentifiers: compareIdentifiers$1,
+  rcompareIdentifiers,
+};
+
+const debug = debug_1;
+const { MAX_LENGTH, MAX_SAFE_INTEGER } = constants$1;
+const { safeRe: re$1, t: t$1 } = reExports;
+
+const parseOptions = parseOptions_1;
+const { compareIdentifiers } = identifiers$1;
+
+const isPrereleaseIdentifier = (prerelease, identifier) => {
+  const identifiers = identifier.split('.');
+  if (identifiers.length > prerelease.length) {
+    return false
+  }
+
+  for (let i = 0; i < identifiers.length; i++) {
+    if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) {
+      return false
+    }
+  }
+
+  return true
+};
+
+let SemVer$1 = class SemVer {
+  constructor (version, options) {
+    options = parseOptions(options);
+
+    if (version instanceof SemVer) {
+      if (version.loose === !!options.loose &&
+        version.includePrerelease === !!options.includePrerelease) {
+        return version
+      } else {
+        version = version.version;
+      }
+    } else if (typeof version !== 'string') {
+      throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`)
+    }
+
+    if (version.length > MAX_LENGTH) {
+      throw new TypeError(
+        `version is longer than ${MAX_LENGTH} characters`
+      )
+    }
+
+    debug('SemVer', version, options);
+    this.options = options;
+    this.loose = !!options.loose;
+    // this isn't actually relevant for versions, but keep it so that we
+    // don't run into trouble passing this.options around.
+    this.includePrerelease = !!options.includePrerelease;
+
+    const m = version.trim().match(options.loose ? re$1[t$1.LOOSE] : re$1[t$1.FULL]);
+
+    if (!m) {
+      throw new TypeError(`Invalid Version: ${version}`)
+    }
+
+    this.raw = version;
+
+    // these are actually numbers
+    this.major = +m[1];
+    this.minor = +m[2];
+    this.patch = +m[3];
+
+    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+      throw new TypeError('Invalid major version')
+    }
+
+    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+      throw new TypeError('Invalid minor version')
+    }
+
+    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+      throw new TypeError('Invalid patch version')
+    }
+
+    // numberify any prerelease numeric ids
+    if (!m[4]) {
+      this.prerelease = [];
+    } else {
+      this.prerelease = m[4].split('.').map((id) => {
+        if (/^[0-9]+$/.test(id)) {
+          const num = +id;
+          if (num >= 0 && num < MAX_SAFE_INTEGER) {
+            return num
+          }
+        }
+        return id
+      });
+    }
+
+    this.build = m[5] ? m[5].split('.') : [];
+    this.format();
+  }
+
+  format () {
+    this.version = `${this.major}.${this.minor}.${this.patch}`;
+    if (this.prerelease.length) {
+      this.version += `-${this.prerelease.join('.')}`;
+    }
+    return this.version
+  }
+
+  toString () {
+    return this.version
+  }
+
+  compare (other) {
+    debug('SemVer.compare', this.version, this.options, other);
+    if (!(other instanceof SemVer)) {
+      if (typeof other === 'string' && other === this.version) {
+        return 0
+      }
+      other = new SemVer(other, this.options);
+    }
+
+    if (other.version === this.version) {
+      return 0
+    }
+
+    return this.compareMain(other) || this.comparePre(other)
+  }
+
+  compareMain (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options);
+    }
+
+    if (this.major < other.major) {
+      return -1
+    }
+    if (this.major > other.major) {
+      return 1
+    }
+    if (this.minor < other.minor) {
+      return -1
+    }
+    if (this.minor > other.minor) {
+      return 1
+    }
+    if (this.patch < other.patch) {
+      return -1
+    }
+    if (this.patch > other.patch) {
+      return 1
+    }
+    return 0
+  }
+
+  comparePre (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options);
+    }
+
+    // NOT having a prerelease is > having one
+    if (this.prerelease.length && !other.prerelease.length) {
+      return -1
+    } else if (!this.prerelease.length && other.prerelease.length) {
+      return 1
+    } else if (!this.prerelease.length && !other.prerelease.length) {
+      return 0
+    }
+
+    let i = 0;
+    do {
+      const a = this.prerelease[i];
+      const b = other.prerelease[i];
+      debug('prerelease compare', i, a, b);
+      if (a === undefined && b === undefined) {
+        return 0
+      } else if (b === undefined) {
+        return 1
+      } else if (a === undefined) {
+        return -1
+      } else if (a === b) {
+        continue
+      } else {
+        return compareIdentifiers(a, b)
+      }
+    } while (++i)
+  }
+
+  compareBuild (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options);
+    }
+
+    let i = 0;
+    do {
+      const a = this.build[i];
+      const b = other.build[i];
+      debug('build compare', i, a, b);
+      if (a === undefined && b === undefined) {
+        return 0
+      } else if (b === undefined) {
+        return 1
+      } else if (a === undefined) {
+        return -1
+      } else if (a === b) {
+        continue
+      } else {
+        return compareIdentifiers(a, b)
+      }
+    } while (++i)
+  }
+
+  // preminor will bump the version up to the next minor release, and immediately
+  // down to pre-release. premajor and prepatch work the same way.
+  inc (release, identifier, identifierBase) {
+    if (release.startsWith('pre')) {
+      if (!identifier && identifierBase === false) {
+        throw new Error('invalid increment argument: identifier is empty')
+      }
+      // Avoid an invalid semver results
+      if (identifier) {
+        const match = `-${identifier}`.match(this.options.loose ? re$1[t$1.PRERELEASELOOSE] : re$1[t$1.PRERELEASE]);
+        if (!match || match[1] !== identifier) {
+          throw new Error(`invalid identifier: ${identifier}`)
+        }
+      }
+    }
+
+    switch (release) {
+      case 'premajor':
+        this.prerelease.length = 0;
+        this.patch = 0;
+        this.minor = 0;
+        this.major++;
+        this.inc('pre', identifier, identifierBase);
+        break
+      case 'preminor':
+        this.prerelease.length = 0;
+        this.patch = 0;
+        this.minor++;
+        this.inc('pre', identifier, identifierBase);
+        break
+      case 'prepatch':
+        // If this is already a prerelease, it will bump to the next version
+        // drop any prereleases that might already exist, since they are not
+        // relevant at this point.
+        this.prerelease.length = 0;
+        this.inc('patch', identifier, identifierBase);
+        this.inc('pre', identifier, identifierBase);
+        break
+      // If the input is a non-prerelease version, this acts the same as
+      // prepatch.
+      case 'prerelease':
+        if (this.prerelease.length === 0) {
+          this.inc('patch', identifier, identifierBase);
+        }
+        this.inc('pre', identifier, identifierBase);
+        break
+      case 'release':
+        if (this.prerelease.length === 0) {
+          throw new Error(`version ${this.raw} is not a prerelease`)
+        }
+        this.prerelease.length = 0;
+        break
+
+      case 'major':
+        // If this is a pre-major version, bump up to the same major version.
+        // Otherwise increment major.
+        // 1.0.0-5 bumps to 1.0.0
+        // 1.1.0 bumps to 2.0.0
+        if (
+          this.minor !== 0 ||
+          this.patch !== 0 ||
+          this.prerelease.length === 0
+        ) {
+          this.major++;
+        }
+        this.minor = 0;
+        this.patch = 0;
+        this.prerelease = [];
+        break
+      case 'minor':
+        // If this is a pre-minor version, bump up to the same minor version.
+        // Otherwise increment minor.
+        // 1.2.0-5 bumps to 1.2.0
+        // 1.2.1 bumps to 1.3.0
+        if (this.patch !== 0 || this.prerelease.length === 0) {
+          this.minor++;
+        }
+        this.patch = 0;
+        this.prerelease = [];
+        break
+      case 'patch':
+        // If this is not a pre-release version, it will increment the patch.
+        // If it is a pre-release it will bump up to the same patch version.
+        // 1.2.0-5 patches to 1.2.0
+        // 1.2.0 patches to 1.2.1
+        if (this.prerelease.length === 0) {
+          this.patch++;
+        }
+        this.prerelease = [];
+        break
+      // This probably shouldn't be used publicly.
+      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+      case 'pre': {
+        const base = Number(identifierBase) ? 1 : 0;
+
+        if (this.prerelease.length === 0) {
+          this.prerelease = [base];
+        } else {
+          let i = this.prerelease.length;
+          while (--i >= 0) {
+            if (typeof this.prerelease[i] === 'number') {
+              this.prerelease[i]++;
+              i = -2;
+            }
+          }
+          if (i === -1) {
+            // didn't increment anything
+            if (identifier === this.prerelease.join('.') && identifierBase === false) {
+              throw new Error('invalid increment argument: identifier already exists')
+            }
+            this.prerelease.push(base);
+          }
+        }
+        if (identifier) {
+          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+          let prerelease = [identifier, base];
+          if (identifierBase === false) {
+            prerelease = [identifier];
+          }
+          if (isPrereleaseIdentifier(this.prerelease, identifier)) {
+            const prereleaseBase = this.prerelease[identifier.split('.').length];
+            if (isNaN(prereleaseBase)) {
+              this.prerelease = prerelease;
+            }
+          } else {
+            this.prerelease = prerelease;
+          }
+        }
+        break
+      }
+      default:
+        throw new Error(`invalid increment argument: ${release}`)
+    }
+    this.raw = this.format();
+    if (this.build.length) {
+      this.raw += `+${this.build.join('.')}`;
+    }
+    return this
+  }
+};
+
+var semver = SemVer$1;
+
+const SemVer = semver;
+const compare$6 = (a, b, loose) =>
+  new SemVer(a, loose).compare(new SemVer(b, loose));
+
+var compare_1 = compare$6;
+
+const compare$5 = compare_1;
+const gt$1 = (a, b, loose) => compare$5(a, b, loose) > 0;
+var gt_1 = gt$1;
+
+const compare$4 = compare_1;
+const lt$1 = (a, b, loose) => compare$4(a, b, loose) < 0;
+var lt_1 = lt$1;
+
+const compare$3 = compare_1;
+const eq$1 = (a, b, loose) => compare$3(a, b, loose) === 0;
+var eq_1 = eq$1;
+
+const compare$2 = compare_1;
+const neq$1 = (a, b, loose) => compare$2(a, b, loose) !== 0;
+var neq_1 = neq$1;
+
+const compare$1 = compare_1;
+const gte$1 = (a, b, loose) => compare$1(a, b, loose) >= 0;
+var gte_1 = gte$1;
+
+const compare = compare_1;
+const lte$1 = (a, b, loose) => compare(a, b, loose) <= 0;
+var lte_1 = lte$1;
+
+const eq = eq_1;
+const neq = neq_1;
+const gt = gt_1;
+const gte = gte_1;
+const lt = lt_1;
+const lte = lte_1;
+
+const cmp = (a, op, b, loose) => {
+  switch (op) {
+    case '===':
+      if (typeof a === 'object') {
+        a = a.version;
+      }
+      if (typeof b === 'object') {
+        b = b.version;
+      }
+      return a === b
+
+    case '!==':
+      if (typeof a === 'object') {
+        a = a.version;
+      }
+      if (typeof b === 'object') {
+        b = b.version;
+      }
+      return a !== b
+
+    case '':
+    case '=':
+    case '==':
+      return eq(a, b, loose)
+
+    case '!=':
+      return neq(a, b, loose)
+
+    case '>':
+      return gt(a, b, loose)
+
+    case '>=':
+      return gte(a, b, loose)
+
+    case '<':
+      return lt(a, b, loose)
+
+    case '<=':
+      return lte(a, b, loose)
+
+    default:
+      throw new TypeError(`Invalid operator: ${op}`)
+  }
+};
+var cmp_1 = cmp;
+
+const { safeRe: re, t } = reExports;
+
+class LRUCache {
+  constructor () {
+    this.max = 1000;
+    this.map = new Map();
+  }
+
+  get (key) {
+    const value = this.map.get(key);
+    if (value === undefined) {
+      return undefined
+    } else {
+      // Remove the key from the map and add it to the end
+      this.map.delete(key);
+      this.map.set(key, value);
+      return value
+    }
+  }
+
+  delete (key) {
+    return this.map.delete(key)
+  }
+
+  set (key, value) {
+    const deleted = this.delete(key);
+
+    if (!deleted && value !== undefined) {
+      // If cache is full, delete the least recently used item
+      if (this.map.size >= this.max) {
+        const firstKey = this.map.keys().next().value;
+        this.delete(firstKey);
+      }
+
+      this.map.set(key, value);
+    }
+
+    return this
+  }
+}
+
+var lrucache = LRUCache;
+
+var range;
+var hasRequiredRange;
+
+function requireRange () {
+	if (hasRequiredRange) return range;
+	hasRequiredRange = 1;
+
+	const SPACE_CHARACTERS = /\s+/g;
+
+	// hoisted class for cyclic dependency
+	class Range {
+	  constructor (range, options) {
+	    options = parseOptions(options);
+
+	    if (range instanceof Range) {
+	      if (
+	        range.loose === !!options.loose &&
+	        range.includePrerelease === !!options.includePrerelease
+	      ) {
+	        return range
+	      } else {
+	        return new Range(range.raw, options)
+	      }
+	    }
+
+	    if (range instanceof Comparator) {
+	      // just put it in the set and return
+	      this.raw = range.value;
+	      this.set = [[range]];
+	      this.formatted = undefined;
+	      return this
+	    }
+
+	    this.options = options;
+	    this.loose = !!options.loose;
+	    this.includePrerelease = !!options.includePrerelease;
+
+	    // First reduce all whitespace as much as possible so we do not have to rely
+	    // on potentially slow regexes like \s*. This is then stored and used for
+	    // future error messages as well.
+	    this.raw = range.trim().replace(SPACE_CHARACTERS, ' ');
+
+	    // First, split on ||
+	    this.set = this.raw
+	      .split('||')
+	      // map the range to a 2d array of comparators
+	      .map(r => this.parseRange(r.trim()))
+	      // throw out any comparator lists that are empty
+	      // this generally means that it was not a valid range, which is allowed
+	      // in loose mode, but will still throw if the WHOLE range is invalid.
+	      .filter(c => c.length);
+
+	    if (!this.set.length) {
+	      throw new TypeError(`Invalid SemVer Range: ${this.raw}`)
+	    }
+
+	    // if we have any that are not the null set, throw out null sets.
+	    if (this.set.length > 1) {
+	      // keep the first one, in case they're all null sets
+	      const first = this.set[0];
+	      this.set = this.set.filter(c => !isNullSet(c[0]));
+	      if (this.set.length === 0) {
+	        this.set = [first];
+	      } else if (this.set.length > 1) {
+	        // if we have any that are *, then the range is just *
+	        for (const c of this.set) {
+	          if (c.length === 1 && isAny(c[0])) {
+	            this.set = [c];
+	            break
+	          }
+	        }
+	      }
+	    }
+
+	    this.formatted = undefined;
+	  }
+
+	  get range () {
+	    if (this.formatted === undefined) {
+	      this.formatted = '';
+	      for (let i = 0; i < this.set.length; i++) {
+	        if (i > 0) {
+	          this.formatted += '||';
+	        }
+	        const comps = this.set[i];
+	        for (let k = 0; k < comps.length; k++) {
+	          if (k > 0) {
+	            this.formatted += ' ';
+	          }
+	          this.formatted += comps[k].toString().trim();
+	        }
+	      }
+	    }
+	    return this.formatted
+	  }
+
+	  format () {
+	    return this.range
+	  }
+
+	  toString () {
+	    return this.range
+	  }
+
+	  parseRange (range) {
+	    // strip build metadata so it can't bleed into the version
+	    range = range.replace(BUILDSTRIPRE, '');
+
+	    // memoize range parsing for performance.
+	    // this is a very hot path, and fully deterministic.
+	    const memoOpts =
+	      (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) |
+	      (this.options.loose && FLAG_LOOSE);
+	    const memoKey = memoOpts + ':' + range;
+	    const cached = cache.get(memoKey);
+	    if (cached) {
+	      return cached
+	    }
+
+	    const loose = this.options.loose;
+	    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+	    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+	    range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+	    debug('hyphen replace', range);
+
+	    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+	    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+	    debug('comparator trim', range);
+
+	    // `~ 1.2.3` => `~1.2.3`
+	    range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+	    debug('tilde trim', range);
+
+	    // `^ 1.2.3` => `^1.2.3`
+	    range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+	    debug('caret trim', range);
+
+	    // At this point, the range is completely trimmed and
+	    // ready to be split into comparators.
+
+	    let rangeList = range
+	      .split(' ')
+	      .map(comp => parseComparator(comp, this.options))
+	      .join(' ')
+	      .split(/\s+/)
+	      // >=0.0.0 is equivalent to *
+	      .map(comp => replaceGTE0(comp, this.options));
+
+	    if (loose) {
+	      // in loose mode, throw out any that are not valid comparators
+	      rangeList = rangeList.filter(comp => {
+	        debug('loose invalid filter', comp, this.options);
+	        return !!comp.match(re[t.COMPARATORLOOSE])
+	      });
+	    }
+	    debug('range list', rangeList);
+
+	    // if any comparators are the null set, then replace with JUST null set
+	    // if more than one comparator, remove any * comparators
+	    // also, don't include the same comparator more than once
+	    const rangeMap = new Map();
+	    const comparators = rangeList.map(comp => new Comparator(comp, this.options));
+	    for (const comp of comparators) {
+	      if (isNullSet(comp)) {
+	        return [comp]
+	      }
+	      rangeMap.set(comp.value, comp);
+	    }
+	    if (rangeMap.size > 1 && rangeMap.has('')) {
+	      rangeMap.delete('');
+	    }
+
+	    const result = [...rangeMap.values()];
+	    cache.set(memoKey, result);
+	    return result
+	  }
+
+	  intersects (range, options) {
+	    if (!(range instanceof Range)) {
+	      throw new TypeError('a Range is required')
+	    }
+
+	    return this.set.some((thisComparators) => {
+	      return (
+	        isSatisfiable(thisComparators, options) &&
+	        range.set.some((rangeComparators) => {
+	          return (
+	            isSatisfiable(rangeComparators, options) &&
+	            thisComparators.every((thisComparator) => {
+	              return rangeComparators.every((rangeComparator) => {
+	                return thisComparator.intersects(rangeComparator, options)
+	              })
+	            })
+	          )
+	        })
+	      )
+	    })
+	  }
+
+	  // if ANY of the sets match ALL of its comparators, then pass
+	  test (version) {
+	    if (!version) {
+	      return false
+	    }
+
+	    if (typeof version === 'string') {
+	      try {
+	        version = new SemVer(version, this.options);
+	      } catch (er) {
+	        return false
+	      }
+	    }
+
+	    for (let i = 0; i < this.set.length; i++) {
+	      if (testSet(this.set[i], version, this.options)) {
+	        return true
+	      }
+	    }
+	    return false
+	  }
+	}
+
+	range = Range;
+
+	const LRU = lrucache;
+	const cache = new LRU();
+
+	const parseOptions = parseOptions_1;
+	const Comparator = requireComparator();
+	const debug = debug_1;
+	const SemVer = semver;
+	const {
+	  safeRe: re,
+	  src,
+	  t,
+	  comparatorTrimReplace,
+	  tildeTrimReplace,
+	  caretTrimReplace,
+	} = reExports;
+	const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = constants$1;
+
+	// unbounded global build-metadata stripper used by parseRange
+	const BUILDSTRIPRE = new RegExp(src[t.BUILD], 'g');
+
+	const isNullSet = c => c.value === '<0.0.0-0';
+	const isAny = c => c.value === '';
+
+	// take a set of comparators and determine whether there
+	// exists a version which can satisfy it
+	const isSatisfiable = (comparators, options) => {
+	  let result = true;
+	  const remainingComparators = comparators.slice();
+	  let testComparator = remainingComparators.pop();
+
+	  while (result && remainingComparators.length) {
+	    result = remainingComparators.every((otherComparator) => {
+	      return testComparator.intersects(otherComparator, options)
+	    });
+
+	    testComparator = remainingComparators.pop();
+	  }
+
+	  return result
+	};
+
+	// comprised of xranges, tildes, stars, and gtlt's at this point.
+	// already replaced the hyphen ranges
+	// turn into a set of JUST comparators.
+	const parseComparator = (comp, options) => {
+	  comp = comp.replace(re[t.BUILD], '');
+	  debug('comp', comp, options);
+	  comp = replaceCarets(comp, options);
+	  debug('caret', comp);
+	  comp = replaceTildes(comp, options);
+	  debug('tildes', comp);
+	  comp = replaceXRanges(comp, options);
+	  debug('xrange', comp);
+	  comp = replaceStars(comp, options);
+	  debug('stars', comp);
+	  return comp
+	};
+
+	const isX = id => !id || id.toLowerCase() === 'x' || id === '*';
+
+	const invalidXRangeOrder = (M, m, p) => (
+	  (isX(M) && !isX(m)) ||
+	  (isX(m) && p && !isX(p))
+	);
+
+	// ~, ~> --> * (any, kinda silly)
+	// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
+	// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
+	// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
+	// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
+	// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
+	// ~0.0.1 --> >=0.0.1 <0.1.0-0
+	const replaceTildes = (comp, options) => {
+	  return comp
+	    .trim()
+	    .split(/\s+/)
+	    .map((c) => replaceTilde(c, options))
+	    .join(' ')
+	};
+
+	const replaceTilde = (comp, options) => {
+	  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+	  // if we're including prereleases in the match, then the lower bound is
+	  // -0, the lowest possible prerelease value, just like x-ranges and carets.
+	  // this keeps `~1.2` equivalent to the `1.2.x` x-range it's documented as.
+	  const z = options.includePrerelease ? '-0' : '';
+	  return comp.replace(r, (_, M, m, p, pr) => {
+	    debug('tilde', comp, _, M, m, p, pr);
+	    let ret;
+
+	    if (isX(M)) {
+	      ret = '';
+	    } else if (isX(m)) {
+	      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+	    } else if (isX(p)) {
+	      // ~1.2 == >=1.2.0 <1.3.0-0
+	      ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+	    } else if (pr) {
+	      debug('replaceTilde pr', pr);
+	      ret = `>=${M}.${m}.${p}-${pr
+	      } <${M}.${+m + 1}.0-0`;
+	    } else {
+	      // ~1.2.3 == >=1.2.3 <1.3.0-0
+	      ret = `>=${M}.${m}.${p
+	      } <${M}.${+m + 1}.0-0`;
+	    }
+
+	    debug('tilde return', ret);
+	    return ret
+	  })
+	};
+
+	// ^ --> * (any, kinda silly)
+	// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
+	// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
+	// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
+	// ^1.2.3 --> >=1.2.3 <2.0.0-0
+	// ^1.2.0 --> >=1.2.0 <2.0.0-0
+	// ^0.0.1 --> >=0.0.1 <0.0.2-0
+	// ^0.1.0 --> >=0.1.0 <0.2.0-0
+	const replaceCarets = (comp, options) => {
+	  return comp
+	    .trim()
+	    .split(/\s+/)
+	    .map((c) => replaceCaret(c, options))
+	    .join(' ')
+	};
+
+	const replaceCaret = (comp, options) => {
+	  debug('caret', comp, options);
+	  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+	  const z = options.includePrerelease ? '-0' : '';
+	  return comp.replace(r, (_, M, m, p, pr) => {
+	    debug('caret', comp, _, M, m, p, pr);
+	    let ret;
+
+	    if (isX(M)) {
+	      ret = '';
+	    } else if (isX(m)) {
+	      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+	    } else if (isX(p)) {
+	      if (M === '0') {
+	        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+	      } else {
+	        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+	      }
+	    } else if (pr) {
+	      debug('replaceCaret pr', pr);
+	      if (M === '0') {
+	        if (m === '0') {
+	          ret = `>=${M}.${m}.${p}-${pr
+	          } <${M}.${m}.${+p + 1}-0`;
+	        } else {
+	          ret = `>=${M}.${m}.${p}-${pr
+	          } <${M}.${+m + 1}.0-0`;
+	        }
+	      } else {
+	        ret = `>=${M}.${m}.${p}-${pr
+	        } <${+M + 1}.0.0-0`;
+	      }
+	    } else {
+	      debug('no pr');
+	      if (M === '0') {
+	        if (m === '0') {
+	          ret = `>=${M}.${m}.${p
+	          } <${M}.${m}.${+p + 1}-0`;
+	        } else {
+	          ret = `>=${M}.${m}.${p
+	          } <${M}.${+m + 1}.0-0`;
+	        }
+	      } else {
+	        ret = `>=${M}.${m}.${p
+	        } <${+M + 1}.0.0-0`;
+	      }
+	    }
+
+	    debug('caret return', ret);
+	    return ret
+	  })
+	};
+
+	const replaceXRanges = (comp, options) => {
+	  debug('replaceXRanges', comp, options);
+	  return comp
+	    .split(/\s+/)
+	    .map((c) => replaceXRange(c, options))
+	    .join(' ')
+	};
+
+	const replaceXRange = (comp, options) => {
+	  comp = comp.trim();
+	  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+	  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+	    debug('xRange', comp, ret, gtlt, M, m, p, pr);
+	    if (invalidXRangeOrder(M, m, p)) {
+	      return comp
+	    }
+
+	    const xM = isX(M);
+	    const xm = xM || isX(m);
+	    const xp = xm || isX(p);
+	    const anyX = xp;
+
+	    if (gtlt === '=' && anyX) {
+	      gtlt = '';
+	    }
+
+	    // if we're including prereleases in the match, then we need
+	    // to fix this to -0, the lowest possible prerelease value
+	    pr = options.includePrerelease ? '-0' : '';
+
+	    if (xM) {
+	      if (gtlt === '>' || gtlt === '<') {
+	        // nothing is allowed
+	        ret = '<0.0.0-0';
+	      } else {
+	        // nothing is forbidden
+	        ret = '*';
+	      }
+	    } else if (gtlt && anyX) {
+	      // we know patch is an x, because we have any x at all.
+	      // replace X with 0
+	      if (xm) {
+	        m = 0;
+	      }
+	      p = 0;
+
+	      if (gtlt === '>') {
+	        // >1 => >=2.0.0
+	        // >1.2 => >=1.3.0
+	        gtlt = '>=';
+	        if (xm) {
+	          M = +M + 1;
+	          m = 0;
+	          p = 0;
+	        } else {
+	          m = +m + 1;
+	          p = 0;
+	        }
+	      } else if (gtlt === '<=') {
+	        // <=0.7.x is actually <0.8.0, since any 0.7.x should
+	        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
+	        gtlt = '<';
+	        if (xm) {
+	          M = +M + 1;
+	        } else {
+	          m = +m + 1;
+	        }
+	      }
+
+	      if (gtlt === '<') {
+	        pr = '-0';
+	      }
+
+	      ret = `${gtlt + M}.${m}.${p}${pr}`;
+	    } else if (xm) {
+	      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+	    } else if (xp) {
+	      ret = `>=${M}.${m}.0${pr
+	      } <${M}.${+m + 1}.0-0`;
+	    }
+
+	    debug('xRange return', ret);
+
+	    return ret
+	  })
+	};
+
+	// Because * is AND-ed with everything else in the comparator,
+	// and '' means "any version", just remove the *s entirely.
+	const replaceStars = (comp, options) => {
+	  debug('replaceStars', comp, options);
+	  // Looseness is ignored here.  star is always as loose as it gets!
+	  return comp
+	    .trim()
+	    .replace(re[t.STAR], '')
+	};
+
+	const replaceGTE0 = (comp, options) => {
+	  debug('replaceGTE0', comp, options);
+	  return comp
+	    .trim()
+	    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
+	};
+
+	// This function is passed to string.replace(re[t.HYPHENRANGE])
+	// M, m, patch, prerelease, build
+	// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+	// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
+	// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
+	// TODO build?
+	const hyphenReplace = incPr => ($0,
+	  from, fM, fm, fp, fpr, fb,
+	  to, tM, tm, tp, tpr) => {
+	  if (isX(fM)) {
+	    from = '';
+	  } else if (isX(fm)) {
+	    from = `>=${fM}.0.0${incPr ? '-0' : ''}`;
+	  } else if (isX(fp)) {
+	    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`;
+	  } else if (fpr) {
+	    from = `>=${from}`;
+	  } else {
+	    from = `>=${from}${incPr ? '-0' : ''}`;
+	  }
+
+	  if (isX(tM)) {
+	    to = '';
+	  } else if (isX(tm)) {
+	    to = `<${+tM + 1}.0.0-0`;
+	  } else if (isX(tp)) {
+	    to = `<${tM}.${+tm + 1}.0-0`;
+	  } else if (tpr) {
+	    to = `<=${tM}.${tm}.${tp}-${tpr}`;
+	  } else if (incPr) {
+	    to = `<${tM}.${tm}.${+tp + 1}-0`;
+	  } else {
+	    to = `<=${to}`;
+	  }
+
+	  return `${from} ${to}`.trim()
+	};
+
+	const testSet = (set, version, options) => {
+	  for (let i = 0; i < set.length; i++) {
+	    if (!set[i].test(version)) {
+	      return false
+	    }
+	  }
+
+	  if (version.prerelease.length && !options.includePrerelease) {
+	    // Find the set of versions that are allowed to have prereleases
+	    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+	    // That should allow `1.2.3-pr.2` to pass.
+	    // However, `1.2.4-alpha.notready` should NOT be allowed,
+	    // even though it's within the range set by the comparators.
+	    for (let i = 0; i < set.length; i++) {
+	      debug(set[i].semver);
+	      if (set[i].semver === Comparator.ANY) {
+	        continue
+	      }
+
+	      if (set[i].semver.prerelease.length > 0) {
+	        const allowed = set[i].semver;
+	        if (allowed.major === version.major &&
+	            allowed.minor === version.minor &&
+	            allowed.patch === version.patch) {
+	          return true
+	        }
+	      }
+	    }
+
+	    // Version has a -pre, but it's not one of the ones we like.
+	    return false
+	  }
+
+	  return true
+	};
+	return range;
+}
+
+var comparator;
+var hasRequiredComparator;
+
+function requireComparator () {
+	if (hasRequiredComparator) return comparator;
+	hasRequiredComparator = 1;
+
+	const ANY = Symbol('SemVer ANY');
+	// hoisted class for cyclic dependency
+	class Comparator {
+	  static get ANY () {
+	    return ANY
+	  }
+
+	  constructor (comp, options) {
+	    options = parseOptions(options);
+
+	    if (comp instanceof Comparator) {
+	      if (comp.loose === !!options.loose) {
+	        return comp
+	      } else {
+	        comp = comp.value;
+	      }
+	    }
+
+	    comp = comp.trim().split(/\s+/).join(' ');
+	    debug('comparator', comp, options);
+	    this.options = options;
+	    this.loose = !!options.loose;
+	    this.parse(comp);
+
+	    if (this.semver === ANY) {
+	      this.value = '';
+	    } else {
+	      this.value = this.operator + this.semver.version;
+	    }
+
+	    debug('comp', this);
+	  }
+
+	  parse (comp) {
+	    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+	    const m = comp.match(r);
+
+	    if (!m) {
+	      throw new TypeError(`Invalid comparator: ${comp}`)
+	    }
+
+	    this.operator = m[1] !== undefined ? m[1] : '';
+	    if (this.operator === '=') {
+	      this.operator = '';
+	    }
+
+	    // if it literally is just '>' or '' then allow anything.
+	    if (!m[2]) {
+	      this.semver = ANY;
+	    } else {
+	      this.semver = new SemVer(m[2], this.options.loose);
+	    }
+	  }
+
+	  toString () {
+	    return this.value
+	  }
+
+	  test (version) {
+	    debug('Comparator.test', version, this.options.loose);
+
+	    if (this.semver === ANY || version === ANY) {
+	      return true
+	    }
+
+	    if (typeof version === 'string') {
+	      try {
+	        version = new SemVer(version, this.options);
+	      } catch (er) {
+	        return false
+	      }
+	    }
+
+	    return cmp(version, this.operator, this.semver, this.options)
+	  }
+
+	  intersects (comp, options) {
+	    if (!(comp instanceof Comparator)) {
+	      throw new TypeError('a Comparator is required')
+	    }
+
+	    if (this.operator === '') {
+	      if (this.value === '') {
+	        return true
+	      }
+	      return new Range(comp.value, options).test(this.value)
+	    } else if (comp.operator === '') {
+	      if (comp.value === '') {
+	        return true
+	      }
+	      return new Range(this.value, options).test(comp.semver)
+	    }
+
+	    options = parseOptions(options);
+
+	    // Special cases where nothing can possibly be lower
+	    if (options.includePrerelease &&
+	      (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {
+	      return false
+	    }
+	    if (!options.includePrerelease &&
+	      (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {
+	      return false
+	    }
+
+	    // Same direction increasing (> or >=)
+	    if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {
+	      return true
+	    }
+	    // Same direction decreasing (< or <=)
+	    if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {
+	      return true
+	    }
+	    // same SemVer and both sides are inclusive (<= or >=)
+	    if (
+	      (this.semver.version === comp.semver.version) &&
+	      this.operator.includes('=') && comp.operator.includes('=')) {
+	      return true
+	    }
+	    // opposite directions less than
+	    if (cmp(this.semver, '<', comp.semver, options) &&
+	      this.operator.startsWith('>') && comp.operator.startsWith('<')) {
+	      return true
+	    }
+	    // opposite directions greater than
+	    if (cmp(this.semver, '>', comp.semver, options) &&
+	      this.operator.startsWith('<') && comp.operator.startsWith('>')) {
+	      return true
+	    }
+	    return false
+	  }
+	}
+
+	comparator = Comparator;
+
+	const parseOptions = parseOptions_1;
+	const { safeRe: re, t } = reExports;
+	const cmp = cmp_1;
+	const debug = debug_1;
+	const SemVer = semver;
+	const Range = requireRange();
+	return comparator;
+}
+
+requireRange();
+
+requireRange();
+
+requireRange();
+
+requireRange();
+
+requireRange();
+
+requireRange();
+
+const Comparator$1 = requireComparator();
+const { ANY: ANY$1 } = Comparator$1;
+requireRange();
+
+requireRange();
+
+requireRange();
+const Comparator = requireComparator();
+const { ANY } = Comparator;
+
+[new Comparator('>=0.0.0-0')];
+[new Comparator('>=0.0.0')];
+
+// just pre-load all the stuff that index.js lazily exports
+const internalRe = reExports;
+const constants = constants$1;
+const identifiers = identifiers$1;
+requireComparator();
+requireRange();
+({
+  re: internalRe.re,
+  src: internalRe.src,
+  tokens: internalRe.t,
+  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+  RELEASE_TYPES: constants.RELEASE_TYPES,
+  compareIdentifiers: identifiers.compareIdentifiers,
+  rcompareIdentifiers: identifiers.rcompareIdentifiers,
+});
+
+var _tmpl$$3 = ["<ul", ' class="relationship-picker__selection">', "</ul>"], _tmpl$2$3 = ["<li", ' class="relationship-picker__empty">Buscando...</li>'], _tmpl$3$3 = ["<li", ' class="relationship-picker__empty">Nenhum resultado</li>'], _tmpl$4$3 = ["<ul", ' class="relationship-picker__results"><!--$-->', "<!--/--><!--$-->", "<!--/--><!--$-->", "<!--/--></ul>"], _tmpl$5$3 = ["<div", ' class="relationship-picker"><!--$-->', '<!--/--><input type="search" class="input"', "><!--$-->", "<!--/--></div>"], _tmpl$6$2 = ["<li", "><!--$-->", '<!--/--><button type="button" aria-label="Remover">×</button></li>'], _tmpl$7$2 = ["<li", '><button type="button"><!--$-->', '<!--/--><span class="relationship-picker__type">', "</span></button></li>"];
+function RelationshipPicker(props) {
+  const [query, setQuery] = createSignal("");
+  const [results, setResults] = createSignal([]);
+  const [selected, setSelected] = createSignal([]);
+  const [loading, setLoading] = createSignal(false);
+  const [open, setOpen] = createSignal(false);
+  const selectedIds = createMemo(() => {
+    const value = props.value;
+    if (Array.isArray(value)) return value.map(String);
+    return value ? [String(value)] : [];
+  });
+  return ssr(_tmpl$5$3, ssrHydrationKey(), escape(createComponent(Show, {
+    get when() {
+      return selected().length > 0 || selectedIds().length > 0;
+    },
+    get children() {
+      return ssr(_tmpl$$3, ssrHydrationKey(), escape(createComponent(For, {
+        get each() {
+          return selected();
+        },
+        children: (entry) => ssr(_tmpl$6$2, ssrHydrationKey(), escape(entry.title))
+      })));
+    }
+  })), ssrAttribute("placeholder", escape(props.placeholder ?? "Buscar conteúdo...", true), false) + ssrAttribute("value", escape(query(), true), false), escape(createComponent(Show, {
+    get when() {
+      return memo(() => !!open())() && (loading() || results().length > 0);
+    },
+    get children() {
+      return ssr(_tmpl$4$3, ssrHydrationKey(), escape(createComponent(Show, {
+        get when() {
+          return loading();
+        },
+        get children() {
+          return ssr(_tmpl$2$3, ssrHydrationKey());
+        }
+      })), escape(createComponent(For, {
+        get each() {
+          return results();
+        },
+        children: (option) => ssr(_tmpl$7$2, ssrHydrationKey(), escape(option.title), escape(option.type))
+      })), escape(createComponent(Show, {
+        get when() {
+          return memo(() => !!!loading())() && results().length === 0;
+        },
+        get children() {
+          return ssr(_tmpl$3$3, ssrHydrationKey());
+        }
+      })));
+    }
+  })));
+}
+
+var _tmpl$$2 = ["<span", ' class="field-renderer__required">*</span>'], _tmpl$2$2 = ["<p", ' class="field-renderer__instructions">', "</p>"], _tmpl$3$2 = ["<p", ' class="field-renderer__error" role="alert">', "</p>"], _tmpl$4$2 = ["<div", ' class="field-renderer"', '><label class="field-renderer__label"><!--$-->', "<!--/--><!--$-->", "<!--/--></label><!--$-->", "<!--/--><!--$-->", "<!--/--><!--$-->", "<!--/--></div>"], _tmpl$5$2 = ["<input", ' type="text" class="input"', ">"], _tmpl$6$1 = ["<textarea", ' class="input" rows="4"', "></textarea>"], _tmpl$7$1 = ["<textarea", ' class="input wysiwyg" rows="8"></textarea>'], _tmpl$8$1 = ["<input", ' type="number" class="input"', ">"], _tmpl$9$1 = ["<input", ' type="email" class="input">'], _tmpl$0 = ["<input", ' type="url" class="input" placeholder="https://">'], _tmpl$1 = ["<input", ' type="password" class="input">'], _tmpl$10 = ["<input", ' type="checkbox"', ">"], _tmpl$11 = ["<select", ' class="input"', ">", "</select>"], _tmpl$12 = ["<option", ">", "</option>"], _tmpl$13 = ["<div", ' class="field-renderer__choices">', "</div>"], _tmpl$14 = ["<label", '><input type="radio"', "", "> <!--$-->", "<!--/--></label>"], _tmpl$15 = ["<label", '><input type="checkbox"', "> <!--$-->", "<!--/--></label>"], _tmpl$16 = ["<input", ' type="date" class="input">'], _tmpl$17 = ["<input", ' type="datetime-local" class="input">'], _tmpl$18 = ["<input", ' type="time" class="input">'], _tmpl$19 = ["<input", ' type="color">'], _tmpl$20 = ["<div", ' class="field-renderer__map"><input type="text" class="input" placeholder="Endereço"><input type="number" class="input" placeholder="Latitude (-90 a 90)" step="any" min="-90" max="90"><input type="number" class="input" placeholder="Longitude (-180 a 180)" step="any" min="-180" max="180"></div>'], _tmpl$21 = ["<div", ' class="field-renderer__link"><input type="url" class="input" placeholder="https:// ou /caminho"><select class="input"><option value="_self">Mesma janela</option><option value="_blank">Nova janela</option></select></div>'], _tmpl$22 = ["<div", ' class="field-renderer__rows"><!--$-->', '<!--/--><button type="button" class="btn">+ Adicionar linha</button></div>'], _tmpl$23 = ["<div", ' class="field-renderer__rows"><!--$-->', '<!--/--><select class="input" value><option value>+ Adicionar layout...</option><!--$-->', "<!--/--></select></div>"], _tmpl$24 = ["<div", ' class="field-renderer__row"><div class="field-renderer__row-header"><span><!--$-->', "<!--/--> <!--$-->", '<!--/--></span><button type="button" class="btn"', '>↑</button><button type="button" class="btn"', '>↓</button><button type="button" class="btn btn-danger">Remover</button></div><!--$-->', "<!--/--></div>"], _tmpl$25 = ["<p", ' class="field-renderer__instructions">Layout "<!--$-->', '<!--/-->" não encontrado.</p>'], _tmpl$26 = ["<fieldset", ' class="field-renderer__group">', "</fieldset>"], _tmpl$27 = ["<input", ' type="text" class="input">'], _tmpl$28 = ["<div", ' class="field-renderer__row"><div class="field-renderer__row-header"><span>Linha <!--$-->', '<!--/--></span><button type="button" class="btn btn-danger">Remover</button></div><!--$-->', "<!--/--></div>"], _tmpl$29 = ["<input", ' type="file" class="input"', ">"], _tmpl$30 = ["<option", "", ">", "</option>"];
+function isEmpty(value) {
+  return value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0 || typeof value === "boolean" && !value;
+}
+function looseEquals(a, b) {
+  if (typeof b === "boolean") return Boolean(a) === b;
+  const na = Number(a);
+  const nb = Number(b);
+  return a === b || !Number.isNaN(na) && !Number.isNaN(nb) && na === nb;
+}
+function isFieldVisible(field, values) {
+  const logic = field.conditionalLogic;
+  if (!logic?.groups || logic.groups.length === 0) return true;
+  const evaluateGroup = (group) => {
+    const rules = group.rules ?? [];
+    if (rules.length === 0) return true;
+    const results = rules.map((rule) => {
+      const target = values[rule.field];
+      switch (rule.operator) {
+        case "eq":
+          return looseEquals(target, rule.value);
+        case "neq":
+          return !looseEquals(target, rule.value);
+        case "gt":
+          return Number(target) > Number(rule.value);
+        case "lt":
+          return Number(target) < Number(rule.value);
+        case "contains":
+          return Array.isArray(target) ? target.includes(rule.value) : String(target ?? "").includes(String(rule.value));
+        case "pattern_matches":
+          try {
+            return new RegExp(String(rule.value)).test(String(target ?? ""));
+          } catch {
+            return false;
+          }
+        case "has_any_value":
+          return !isEmpty(target);
+        case "has_no_value":
+          return isEmpty(target);
+        default:
+          return false;
+      }
+    });
+    return group.match === "ANY" ? results.some(Boolean) : results.every(Boolean);
+  };
+  return logic.groups.map(evaluateGroup).some(Boolean);
+}
+const LAYOUT_ONLY = /* @__PURE__ */ new Set(["message", "tab", "accordion"]);
+function FieldRenderer(props) {
+  const visible = () => isFieldVisible(props.field, props.values);
+  const [dirty, setDirty] = createSignal(false);
+  const valueFor = () => props.values[props.field.name];
+  const validationError = createMemo(() => {
+    if (!dirty()) return null;
+    return validateFieldClient(props.field, props.values[props.field.name]);
+  });
+  const setValue = (value) => {
+    setDirty(true);
+    props.onChange(props.field.name, value);
+  };
+  return createComponent(Show, {
+    get when() {
+      return memo(() => !!visible())() && !LAYOUT_ONLY.has(props.field.type);
+    },
+    get children() {
+      return ssr(_tmpl$4$2, ssrHydrationKey(), ssrAttribute("data-field-type", escape(props.field.type, true), false), escape(props.field.label), escape(createComponent(Show, {
+        get when() {
+          return props.field.required;
+        },
+        get children() {
+          return ssr(_tmpl$$2, ssrHydrationKey());
+        }
+      })), escape(createComponent(Show, {
+        get when() {
+          return props.field.instructions;
+        },
+        get children() {
+          return ssr(_tmpl$2$2, ssrHydrationKey(), escape(props.field.instructions));
+        }
+      })), escape(createComponent(FieldControl, {
+        get field() {
+          return props.field;
+        },
+        get value() {
+          return valueFor();
+        },
+        onChange: setValue,
+        get values() {
+          return props.values;
+        }
+      })), escape(createComponent(Show, {
+        get when() {
+          return memo(() => !!validationError())() && !validationError()?.valid;
+        },
+        get children() {
+          return ssr(_tmpl$3$2, ssrHydrationKey(), escape(validationError()?.errors.join(", ")));
+        }
+      })));
+    }
+  });
+}
+function FieldControl(props) {
+  const config = () => props.field.config ?? {};
+  switch (props.field.type) {
+    case "text":
+      return ssr(_tmpl$5$2, ssrHydrationKey(), ssrAttribute("maxlength", escape(config()["characterLimit"], true), false));
+    case "textarea":
+      return ssr(_tmpl$6$1, ssrHydrationKey(), ssrAttribute("maxlength", escape(config()["characterLimit"], true), false));
+    case "wysiwyg":
+      return ssr(_tmpl$7$1, ssrHydrationKey());
+    case "number":
+    case "range":
+      return ssr(_tmpl$8$1, ssrHydrationKey(), ssrAttribute("min", escape(config()["minValue"], true), false) + ssrAttribute("max", escape(config()["maxValue"], true), false) + ssrAttribute("step", escape(config()["step"], true), false));
+    case "email":
+      return ssr(_tmpl$9$1, ssrHydrationKey());
+    case "url":
+      return ssr(_tmpl$0, ssrHydrationKey());
+    case "password":
+      return ssr(_tmpl$1, ssrHydrationKey());
+    case "true_false":
+      return ssr(_tmpl$10, ssrHydrationKey(), ssrAttribute("checked", Boolean(props.value), true));
+    case "select":
+      return ssr(_tmpl$11, ssrHydrationKey(), ssrAttribute("multiple", config()["multiple"] === true, true), escape(createComponent(For, {
+        get each() {
+          return config()["choices"] ?? [];
+        },
+        children: (choice) => ssr(_tmpl$12, ssrHydrationKey() + ssrAttribute("value", escape(choice.value, true), false), escape(choice.label))
+      })));
+    case "radio":
+      return ssr(_tmpl$13, ssrHydrationKey(), escape(createComponent(For, {
+        get each() {
+          return config()["choices"] ?? [];
+        },
+        children: (choice) => ssr(_tmpl$14, ssrHydrationKey(), ssrAttribute("name", escape(props.field.name, true), false), ssrAttribute("checked", props.value === choice.value, true), escape(choice.label))
+      })));
+    case "checkbox":
+      return ssr(_tmpl$13, ssrHydrationKey(), escape(createComponent(For, {
+        get each() {
+          return config()["choices"] ?? [];
+        },
+        children: (choice) => {
+          const checked = () => Array.isArray(props.value) && props.value.includes(choice.value);
+          return ssr(_tmpl$15, ssrHydrationKey(), ssrAttribute("checked", checked(), true), escape(choice.label));
+        }
+      })));
+    case "date_picker":
+      return ssr(_tmpl$16, ssrHydrationKey());
+    case "date_time_picker":
+      return ssr(_tmpl$17, ssrHydrationKey());
+    case "time_picker":
+      return ssr(_tmpl$18, ssrHydrationKey());
+    case "color_picker":
+      return ssr(_tmpl$19, ssrHydrationKey());
+    case "image":
+    case "file":
+      return createComponent(MediaPickerInput, {
+        multiple: false,
+        get onChange() {
+          return props.onChange;
+        },
+        get accept() {
+          return props.field.type === "image" ? "image/*" : void 0;
+        }
+      });
+    case "gallery":
+      return createComponent(MediaPickerInput, {
+        multiple: true,
+        get onChange() {
+          return props.onChange;
+        },
+        accept: "image/*"
+      });
+    case "google_map":
+      return ssr(_tmpl$20, ssrHydrationKey());
+    case "link":
+      return ssr(_tmpl$21, ssrHydrationKey());
+    case "relationship":
+    case "post_object":
+      return createComponent(RelationshipPicker, {
+        get postType() {
+          return config()["postType"];
+        },
+        get multiple() {
+          return config()["multiple"] !== false;
+        },
+        get value() {
+          return props.value;
+        },
+        get onChange() {
+          return props.onChange;
+        }
+      });
+    case "taxonomy":
+    case "user":
+      return createComponent(RelationshipSelector, {
+        get field() {
+          return props.field;
+        },
+        get value() {
+          return props.value;
+        },
+        get onChange() {
+          return props.onChange;
+        },
+        get multiple() {
+          return config()["multiple"] !== false;
+        }
+      });
+    case "repeater": {
+      const rows = () => Array.isArray(props.value) ? props.value : [];
+      return ssr(_tmpl$22, ssrHydrationKey(), escape(createComponent(For, {
+        get each() {
+          return rows();
+        },
+        children: (row, index) => createComponent(RepeaterRow, {
+          get field() {
+            return props.field;
+          },
+          row,
+          get index() {
+            return index();
+          },
+          onUpdate: (updated) => {
+            const next = [...rows()];
+            next[index()] = updated;
+            props.onChange(next);
+          },
+          onRemove: () => {
+            props.onChange(rows().filter((_, i) => i !== index()));
+          }
+        })
+      })));
+    }
+    case "flexible_content": {
+      const layouts = () => config()["layouts"] ?? [];
+      const rows = () => {
+        const raw = Array.isArray(props.value) ? props.value : [];
+        return raw.map((row) => ({
+          acf_fc_layout: String(row["acf_fc_layout"] ?? ""),
+          data: row
+        }));
+      };
+      return ssr(_tmpl$23, ssrHydrationKey(), escape(createComponent(For, {
+        get each() {
+          return rows();
+        },
+        children: (row, index) => {
+          const layout = () => layouts().find((entry) => entry.name === row.acf_fc_layout);
+          const rowData = () => {
+            const {
+              acf_fc_layout: _layout,
+              ...data
+            } = row.data;
+            return data;
+          };
+          return ssr(_tmpl$24, ssrHydrationKey(), escape(layout()?.label || row.acf_fc_layout || "Linha"), escape(index()) + 1, ssrAttribute("disabled", index() === 0, true), ssrAttribute("disabled", index() === rows().length - 1, true), escape(createComponent(Show, {
+            get when() {
+              return layout();
+            },
+            get fallback() {
+              return ssr(_tmpl$25, ssrHydrationKey(), escape(row.acf_fc_layout));
+            },
+            get children() {
+              return createComponent(For, {
+                get each() {
+                  return layout().subFields ?? [];
+                },
+                children: (sub) => createComponent(FieldRenderer, {
+                  field: sub,
+                  get values() {
+                    return rowData();
+                  },
+                  onChange: (name, value) => {
+                    const current = [...Array.isArray(props.value) ? props.value : []];
+                    current[index()] = {
+                      ...current[index()],
+                      [name]: value
+                    };
+                    props.onChange(current);
+                  }
+                })
+              });
+            }
+          })));
+        }
+      })), escape(createComponent(For, {
+        get each() {
+          return layouts();
+        },
+        children: (layout) => ssr(_tmpl$12, ssrHydrationKey() + ssrAttribute("value", escape(layout.name, true), false), escape(layout.label ?? layout.name))
+      })));
+    }
+    case "group":
+      return ssr(_tmpl$26, ssrHydrationKey(), escape(createComponent(For, {
+        get each() {
+          return props.field.subFields ?? [];
+        },
+        children: (sub) => createComponent(FieldRenderer, {
+          field: sub,
+          get values() {
+            return props.value ?? {};
+          },
+          onChange: (name, val) => props.onChange({
+            ...props.value ?? {},
+            [name]: val
+          })
+        })
+      })));
+    default:
+      return ssr(_tmpl$27, ssrHydrationKey());
+  }
+}
+function RepeaterRow(props) {
+  return ssr(_tmpl$28, ssrHydrationKey(), escape(props.index) + 1, escape(createComponent(For, {
+    get each() {
+      return props.field.subFields ?? [];
+    },
+    children: (sub) => createComponent(FieldRenderer, {
+      field: sub,
+      get values() {
+        return props.row;
+      },
+      onChange: (name, value) => props.onUpdate({
+        ...props.row,
+        [name]: value
+      })
+    })
+  })));
+}
+function MediaPickerInput(props) {
+  return ssr(_tmpl$29, ssrHydrationKey(), ssrAttribute("multiple", props.multiple, true) + ssrAttribute("accept", escape(props.accept, true), false));
+}
+function RelationshipSelector(props) {
+  const selectedIds = () => Array.isArray(props.value) ? props.value : props.value ? [props.value] : [];
+  return ssr(_tmpl$11, ssrHydrationKey(), ssrAttribute("multiple", props.multiple, true) + ssrAttribute("size", escape(Math.min(6, Math.max(3, (props.field.config?.["choices"] ?? []).length || 3)), true), false), escape(createComponent(For, {
+    get each() {
+      return props.field.config?.["choices"] ?? [];
+    },
+    children: (choice) => ssr(_tmpl$30, ssrHydrationKey() + ssrAttribute("value", escape(choice.value, true), false), ssrAttribute("selected", selectedIds().includes(choice.value), true), escape(choice.label))
+  })));
+}
+
+var _tmpl$$1 = ["<div", ' class="field-type-picker__panel" role="listbox"><input type="search" class="field-type-picker__search" placeholder="Buscar tipo de campo..."', "><!--$-->", "<!--/--></div>"], _tmpl$2$1 = ["<div", ' class="field-type-picker"><button type="button" class="field-type-picker__trigger"', "><span><!--$-->", "<!--/--> <!--$-->", '<!--/--></span><span aria-hidden="true">', "</span></button><!--$-->", "<!--/--></div>"], _tmpl$3$1 = ["<div", ' class="field-type-picker__group"><div class="field-type-picker__group-label"><!--$-->', "<!--/--> <!--$-->", "<!--/--></div><!--$-->", "<!--/--></div>"], _tmpl$4$1 = ["<span", ' class="field-type-picker__hint">sem lógica condicional</span>'], _tmpl$5$1 = ["<button", ' type="button" role="option"', ' class="', '"><span>', "</span><span>", "</span><!--$-->", "<!--/--></button>"];
+function FieldTypePicker(props) {
+  const [open, setOpen] = createSignal(false);
+  const [query, setQuery] = createSignal("");
+  const selected = () => props.types.find((type) => type.type === props.value);
+  const filteredTypes = () => {
+    const q = query().toLowerCase();
+    return q ? props.types.filter((type) => type.label.toLowerCase().includes(q) || type.type.includes(q)) : props.types;
+  };
+  return ssr(_tmpl$2$1, ssrHydrationKey(), ssrAttribute("aria-expanded", escape(open(), true), false), escape(selected()?.icon ?? " "), escape(selected()?.label ?? "Selecione o tipo"), open() ? "▴" : "▾", escape(createComponent(Show, {
+    get when() {
+      return open();
+    },
+    get children() {
+      return ssr(_tmpl$$1, ssrHydrationKey(), ssrAttribute("value", escape(query(), true), false), escape(createComponent(For, {
+        get each() {
+          return props.categories;
+        },
+        children: (category) => {
+          const categoryTypes = filteredTypes().filter((type) => type.category === category.id);
+          return createComponent(Show, {
+            get when() {
+              return categoryTypes.length > 0;
+            },
+            get children() {
+              return ssr(_tmpl$3$1, ssrHydrationKey(), escape(category.icon), escape(category.label), escape(createComponent(For, {
+                each: categoryTypes,
+                children: (type) => ssr(_tmpl$5$1, ssrHydrationKey(), ssrAttribute("aria-selected", escape(props.value, true) === escape(type.type, true), false), `field-type-picker__option ${props.value === type.type ? "is-selected" : ""}`, escape(type.icon), escape(type.label), escape(createComponent(Show, {
+                  get when() {
+                    return !type.supportsConditions;
+                  },
+                  get children() {
+                    return ssr(_tmpl$4$1, ssrHydrationKey());
+                  }
+                })))
+              })));
+            }
+          });
+        }
+      })));
+    }
+  })));
+}
+
+var _tmpl$ = ["<div", ' class="notice notice--success">', "</div>"], _tmpl$2 = ["<label", '>Título<input class="input" required', "></label>"], _tmpl$3 = ["<label", '>Resumo<textarea class="input" rows="3"', "></textarea></label>"], _tmpl$4 = ["<label", '>Imagem destacada (media ID)<input class="input"', "></label>"], _tmpl$5 = ["<label", '>Layout<select class="input"', "><option value>Automático (hierarquia do tema)</option><!--$-->", "<!--/--></select></label>"], _tmpl$6 = ["<div", ' class="card custom-fields"><h3>Campos personalizados</h3><!--$-->', "<!--/--><details><summary>Inspecionar tipos disponíveis</summary><!--$-->", "<!--/--></details></div>"], _tmpl$7 = ["<form", ' class="content-editor"><!--$-->', "<!--/--><!--$-->", '<!--/--><div class="card"><label>Tipo<select class="input"', ">", "</select></label><!--$-->", '<!--/--><label>Slug<input class="input"', "></label><!--$-->", "<!--/--><!--$-->", '<!--/--><label>Status<select class="input"', '><option value="DRAFT">Rascunho</option><option value="PUBLISHED">Publicado</option><option value="ARCHIVED">Arquivado</option></select></label><!--$-->', "<!--/--></div><!--$-->", '<!--/--><button type="submit" class="btn btn-primary"', ">Salvar</button></form>"], _tmpl$8 = ["<div", ' class="notice notice--error">', "</div>"], _tmpl$9 = ["<option", ">", "</option>"];
+function ContentEditor() {
+  const [types, setTypes] = createSignal([]);
+  const [fieldTypes, setFieldTypes] = createSignal([]);
+  const [categories, setCategories] = createSignal([]);
+  const [groups, setGroups] = createSignal([]);
+  const [themes, setThemes] = createSignal([]);
+  const [data, setData] = createSignal({});
+  const [errors, setErrors] = createSignal([]);
+  const [saving, setSaving] = createSignal(false);
+  const [message, setMessage] = createSignal("");
+  const [draft, setDraft] = createSignal({
+    type: "post",
+    title: "",
+    status: "DRAFT"
+  });
+  const supports = () => new Set(types().find((t) => t.slug === draft().type)?.supports ?? ["title", "editor"]);
+  const hasSupport = (support) => supports().has(support);
+  onMount(async () => {
+    try {
+      const [typeList, fieldTypeCatalog, themeList] = await Promise.all([apiClient.getContentTypes(), apiClient.getFieldTypes(), apiClient.getThemes().catch(() => [])]);
+      setTypes(typeList);
+      setFieldTypes(fieldTypeCatalog.types);
+      setCategories(fieldTypeCatalog.categories);
+      setThemes(themeList);
+    } catch (err) {
+      setErrors([err instanceof Error ? err.message : String(err)]);
+    }
+    await loadGroups(draft().type);
+  });
+  const availableLayouts = () => {
+    const layouts = /* @__PURE__ */ new Set();
+    for (const theme of themes()) {
+      for (const layout of theme.manifest?.provides?.layouts ?? []) layouts.add(layout);
+    }
+    return [...layouts].sort();
+  };
+  const loadGroups = async (type) => {
+    try {
+      const all = await apiClient.getFieldGroups(type ? {
+        type
+      } : void 0);
+      const resolved = await Promise.all(all.filter((group) => group.active).map(async (group) => {
+        const full = await apiClient.getFieldGroup(group.id);
+        return full.fields ?? [];
+      }));
+      setGroups(expandCloneFields(resolved.flat()));
+    } catch (err) {
+      setErrors([err instanceof Error ? err.message : String(err)]);
+    }
+  };
+  return ssr(_tmpl$7, ssrHydrationKey(), escape(createComponent(Show, {
+    get when() {
+      return errors().length > 0;
+    },
+    get children() {
+      return createComponent(For, {
+        get each() {
+          return errors();
+        },
+        children: (err) => ssr(_tmpl$8, ssrHydrationKey(), escape(err))
+      });
+    }
+  })), escape(createComponent(Show, {
+    get when() {
+      return message();
+    },
+    get children() {
+      return ssr(_tmpl$, ssrHydrationKey(), escape(message()));
+    }
+  })), ssrAttribute("value", escape(draft().type, true), false), escape(createComponent(For, {
+    get each() {
+      return types();
+    },
+    children: (type) => ssr(_tmpl$9, ssrHydrationKey() + ssrAttribute("value", escape(type.slug, true), false), escape(type.pluralLabel))
+  })), escape(createComponent(Show, {
+    get when() {
+      return hasSupport("title");
+    },
+    get children() {
+      return ssr(_tmpl$2, ssrHydrationKey(), ssrAttribute("value", escape(draft().title, true), false));
+    }
+  })), ssrAttribute("value", escape(draft().slug ?? "", true), false), escape(createComponent(Show, {
+    get when() {
+      return hasSupport("excerpt");
+    },
+    get children() {
+      return ssr(_tmpl$3, ssrHydrationKey(), ssrAttribute("value", escape(draft().excerpt ?? "", true), false));
+    }
+  })), escape(createComponent(Show, {
+    get when() {
+      return hasSupport("thumbnail");
+    },
+    get children() {
+      return ssr(_tmpl$4, ssrHydrationKey(), ssrAttribute("value", escape(draft().featuredImageId ?? "", true), false));
+    }
+  })), ssrAttribute("value", escape(draft().status, true), false), escape(createComponent(Show, {
+    get when() {
+      return availableLayouts().length > 0;
+    },
+    get children() {
+      return ssr(_tmpl$5, ssrHydrationKey(), ssrAttribute("value", escape(draft().layout ?? "", true), false), escape(createComponent(For, {
+        get each() {
+          return availableLayouts();
+        },
+        children: (layout) => ssr(_tmpl$9, ssrHydrationKey() + ssrAttribute("value", escape(layout, true), false), escape(layout))
+      })));
+    }
+  })), escape(createComponent(Show, {
+    get when() {
+      return groups().length > 0 || fieldTypes().length > 0;
+    },
+    get children() {
+      return ssr(_tmpl$6, ssrHydrationKey(), escape(createComponent(For, {
+        get each() {
+          return groups();
+        },
+        children: (field) => createComponent(FieldRenderer, {
+          field,
+          get values() {
+            return data();
+          },
+          onChange: (name, value) => setData({
+            ...data(),
+            [name]: value
+          })
+        })
+      })), escape(createComponent(FieldTypePicker, {
+        get categories() {
+          return categories();
+        },
+        get types() {
+          return fieldTypes();
+        },
+        value: "",
+        onChange: () => void 0
+      })));
+    }
+  })), ssrAttribute("disabled", saving(), true));
+}
+
+const $$Edit = createComponent$1(($$result, $$props, $$slots) => {
+  return renderTemplate`${renderComponent($$result, "DashboardLayout", $$DashboardLayout, { "title": "Editor de Conte\xFAdo", "data-astro-cid-yrprbkbh": true }, { "default": ($$result2) => renderTemplate` ${maybeRenderHead()}<div class="editor-page" data-astro-cid-yrprbkbh> ${renderComponent($$result2, "ContentEditor", ContentEditor, { "client:load": true, "client:component-hydration": "load", "client:component-path": "/home/judah/projetos/blacklotuscms-v2/apps/admin/src/components/content/ContentEditor", "client:component-export": "ContentEditor", "data-astro-cid-yrprbkbh": true })} </div> ` })} `;
+}, "/home/judah/projetos/blacklotuscms-v2/apps/admin/src/pages/content/edit.astro", void 0);
+
+const $$file = "/home/judah/projetos/blacklotuscms-v2/apps/admin/src/pages/content/edit.astro";
+const $$url = "/content/edit";
+
+export { $$Edit as default, $$file as file, $$url as url };