npm - @meethive/vite - Versions diffs - 0.0.1 - Mend

@meethive/vite 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (72) hide show

package/dist/index.d.ts +4 -0
package/dist/index.d.ts.map +1 -0
package/dist/index.js +2118 -0
package/dist/index.mjs +2096 -0
package/dist/src/federation/src/dev/expose-development.d.ts +5 -0
package/dist/src/federation/src/dev/expose-development.d.ts.map +1 -0
package/dist/src/federation/src/dev/remote-development.d.ts +5 -0
package/dist/src/federation/src/dev/remote-development.d.ts.map +1 -0
package/dist/src/federation/src/dev/shared-development.d.ts +5 -0
package/dist/src/federation/src/dev/shared-development.d.ts.map +1 -0
package/dist/src/federation/src/index.d.ts +7 -0
package/dist/src/federation/src/index.d.ts.map +1 -0
package/dist/src/federation/src/prod/expose-production.d.ts +5 -0
package/dist/src/federation/src/prod/expose-production.d.ts.map +1 -0
package/dist/src/federation/src/prod/remote-production.d.ts +7 -0
package/dist/src/federation/src/prod/remote-production.d.ts.map +1 -0
package/dist/src/federation/src/prod/shared-production.d.ts +5 -0
package/dist/src/federation/src/prod/shared-production.d.ts.map +1 -0
package/dist/src/federation/src/public.d.ts +40 -0
package/dist/src/federation/src/public.d.ts.map +1 -0
package/dist/src/federation/src/runtime/dynamic-remote.d.ts +79 -0
package/dist/src/federation/src/runtime/dynamic-remote.d.ts.map +1 -0
package/dist/src/federation/src/utils/html.d.ts +12 -0
package/dist/src/federation/src/utils/html.d.ts.map +1 -0
package/dist/src/federation/src/utils/index.d.ts +29 -0
package/dist/src/federation/src/utils/index.d.ts.map +1 -0
package/dist/src/federation/src/utils/semver/compare.d.ts +10 -0
package/dist/src/federation/src/utils/semver/compare.d.ts.map +1 -0
package/dist/src/federation/src/utils/semver/constants.d.ts +11 -0
package/dist/src/federation/src/utils/semver/constants.d.ts.map +1 -0
package/dist/src/federation/src/utils/semver/parser.d.ts +10 -0
package/dist/src/federation/src/utils/semver/parser.d.ts.map +1 -0
package/dist/src/federation/src/utils/semver/satisfy.d.ts +2 -0
package/dist/src/federation/src/utils/semver/satisfy.d.ts.map +1 -0
package/dist/src/federation/src/utils/semver/utils.d.ts +12 -0
package/dist/src/federation/src/utils/semver/utils.d.ts.map +1 -0
package/dist/src/monaco-editor/index.d.ts +35 -0
package/dist/src/monaco-editor/index.d.ts.map +1 -0
package/dist/src/monaco-editor/languageWork.d.ts +10 -0
package/dist/src/monaco-editor/languageWork.d.ts.map +1 -0
package/dist/src/monaco-editor/workerMiddleware.d.ts +9 -0
package/dist/src/monaco-editor/workerMiddleware.d.ts.map +1 -0
package/dist/src/sharp/index.d.ts +12 -0
package/dist/src/sharp/index.d.ts.map +1 -0
package/index.ts +3 -0
package/package.json +48 -0
package/src/federation/src/dev/expose-development.ts +29 -0
package/src/federation/src/dev/remote-development.ts +435 -0
package/src/federation/src/dev/shared-development.ts +29 -0
package/src/federation/src/index.ts +242 -0
package/src/federation/src/prod/expose-production.ts +333 -0
package/src/federation/src/prod/federation_fn_import.js +75 -0
package/src/federation/src/prod/remote-production.ts +658 -0
package/src/federation/src/prod/shared-production.ts +268 -0
package/src/federation/src/public.ts +54 -0
package/src/federation/src/runtime/dynamic-remote.ts +247 -0
package/src/federation/src/utils/html.ts +165 -0
package/src/federation/src/utils/index.ts +255 -0
package/src/federation/src/utils/semver/compare.ts +131 -0
package/src/federation/src/utils/semver/constants.ts +46 -0
package/src/federation/src/utils/semver/parser.ts +253 -0
package/src/federation/src/utils/semver/satisfy.ts +151 -0
package/src/federation/src/utils/semver/utils.ts +93 -0
package/src/federation/types/dynamic-remote.d.ts +105 -0
package/src/federation/types/index.d.ts +344 -0
package/src/federation/types/pluginHooks.d.ts +4 -0
package/src/federation/types/virtual-modules.d.ts +48 -0
package/src/federation/types/viteDevServer.d.ts +22 -0
package/src/monaco-editor/index.ts +205 -0
package/src/monaco-editor/languageWork.ts +36 -0
package/src/monaco-editor/workerMiddleware.ts +78 -0
package/src/sharp/index.ts +93 -0

package/src/federation/src/utils/html.ts ADDED Viewed

@@ -0,0 +1,165 @@
+export interface HtmlTagDescriptor {
+  tag: string
+  attrs?: Record<string, string | boolean | undefined>
+  children?: string | HtmlTagDescriptor[]
+  /**
+   * default: 'head-prepend'
+   */
+  injectTo?: 'head' | 'body' | 'head-prepend' | 'body-prepend'
+}
+const unaryTags = new Set(['link', 'meta', 'base'])
+function serializeTag(
+  { tag, attrs, children }: HtmlTagDescriptor,
+  indent = ''
+): string {
+  if (unaryTags.has(tag)) {
+    return `<${tag}${serializeAttrs(attrs)}>`
+  } else {
+    return `<${tag}${serializeAttrs(attrs)}>${serializeTags(
+      children,
+      incrementIndent(indent)
+    )}</${tag}>`
+  }
+}
+function serializeTags(
+  tags: HtmlTagDescriptor['children'],
+  indent = ''
+): string {
+  if (typeof tags === 'string') {
+    return tags
+  } else if (tags && tags.length) {
+    return tags.map((tag) => `${indent}${serializeTag(tag, indent)}\n`).join('')
+  }
+  return ''
+}
+function serializeAttrs(attrs: HtmlTagDescriptor['attrs']): string {
+  let res = ''
+  for (const key in attrs) {
+    if (typeof attrs[key] === 'boolean') {
+      res += attrs[key] ? ` ${key}` : ``
+    } else {
+      res += ` ${key}="${escapeHtml(attrs[key])}"`
+    }
+  }
+  return res
+}
+function incrementIndent(indent = '') {
+  return `${indent}${indent[0] === '\t' ? '\t' : '  '}`
+}
+const matchHtmlRegExp = /["'&<>]/
+function escapeHtml(string: any) {
+  const str = '' + string
+  const match = matchHtmlRegExp.exec(str)
+  if (!match) {
+    return str
+  }
+  let escape
+  let html = ''
+  let index = 0
+  let lastIndex = 0
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34: // "
+        escape = '&quot;'
+        break
+      case 38: // &
+        escape = '&amp;'
+        break
+      case 39: // '
+        escape = '&#39;'
+        break
+      case 60: // <
+        escape = '&lt;'
+        break
+      case 62: // >
+        escape = '&gt;'
+        break
+      default:
+        continue
+    }
+    if (lastIndex !== index) {
+      html += str.substring(lastIndex, index)
+    }
+    lastIndex = index + 1
+    html += escape
+  }
+  return lastIndex !== index ? html + str.substring(lastIndex, index) : html
+}
+const headInjectRE = /([ \t]*)<\/head>/i
+const headPrependInjectRE = /([ \t]*)<head[^>]*>/i
+const htmlPrependInjectRE = /([ \t]*)<html[^>]*>/i
+const bodyPrependInjectRE = /([ \t]*)<body[^>]*>/i
+const doctypePrependInjectRE = /<!doctype html>/i
+export const toPreloadTag = (href: string): HtmlTagDescriptor => ({
+  tag: 'link',
+  attrs: {
+    rel: 'modulepreload',
+    crossorigin: true,
+    href
+  }
+})
+export function injectToHead(
+  html: string,
+  tags: HtmlTagDescriptor[],
+  prepend = false
+) {
+  if (tags.length === 0) return html
+  if (prepend) {
+    // inject as the first element of head
+    if (headPrependInjectRE.test(html)) {
+      return html.replace(
+        headPrependInjectRE,
+        (match, p1) => `${match}\n${serializeTags(tags, incrementIndent(p1))}`
+      )
+    }
+  } else {
+    // inject before head close
+    if (headInjectRE.test(html)) {
+      // respect indentation of head tag
+      return html.replace(
+        headInjectRE,
+        (match, p1) => `${serializeTags(tags, incrementIndent(p1))}${match}`
+      )
+    }
+    // try to inject before the body tag
+    if (bodyPrependInjectRE.test(html)) {
+      return html.replace(
+        bodyPrependInjectRE,
+        (match, p1) => `${serializeTags(tags, p1)}\n${match}`
+      )
+    }
+  }
+  // if no head tag is present, we prepend the tag for both prepend and append
+  return prependInjectFallback(html, tags)
+}
+function prependInjectFallback(html: string, tags: HtmlTagDescriptor[]) {
+  // prepend to the html tag, append after doctype, or the document start
+  if (htmlPrependInjectRE.test(html)) {
+    return html.replace(htmlPrependInjectRE, `$&\n${serializeTags(tags)}`)
+  }
+  if (doctypePrependInjectRE.test(html)) {
+    return html.replace(doctypePrependInjectRE, `$&\n${serializeTags(tags)}`)
+  }
+  return serializeTags(tags) + html
+}

package/src/federation/src/utils/index.ts ADDED Viewed

@@ -0,0 +1,255 @@
+// *****************************************************************************
+// Copyright (C) 2022 Origin.js and others.
+//
+// This program and the accompanying materials are licensed under Mulan PSL v2.
+// You can use this software according to the terms and conditions of the Mulan PSL v2.
+// You may obtain a copy of Mulan PSL v2 at:
+//          http://license.coscl.org.cn/MulanPSL2
+// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+// EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+// MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+// See the Mulan PSL v2 for more details.
+//
+// SPDX-License-Identifier: MulanPSL-2.0
+// *****************************************************************************
+import type {
+  ConfigTypeSet,
+  Exposes,
+  Remotes,
+  RemotesConfig,
+  Shared,
+  VitePluginFederationOptions
+} from '../../types'
+import { readFileSync } from 'fs'
+import { createHash } from 'crypto'
+import path, { parse, posix } from 'path'
+import type { PluginContext } from 'rollup'
+export * from './html'
+export function findDependencies(
+  this: PluginContext,
+  id: string,
+  sets: Set<string>,
+  sharedModuleIds: Map<string, string>,
+  usedSharedModuleIds: Set<string>
+): void {
+  if (!sets.has(id)) {
+    sets.add(id)
+    const moduleInfo = this.getModuleInfo(id)
+    if (moduleInfo?.importedIds) {
+      moduleInfo.importedIds.forEach((id) => {
+        findDependencies.apply(this, [
+          id,
+          sets,
+          sharedModuleIds,
+          usedSharedModuleIds
+        ])
+      })
+    }
+    if (sharedModuleIds.has(id)) {
+      usedSharedModuleIds.add(sharedModuleIds.get(id) as string)
+    }
+  }
+}
+export function parseSharedOptions(
+  options: VitePluginFederationOptions
+): (string | ConfigTypeSet)[] {
+  return parseOptions(
+    options.shared || {},
+    (value, key) => ({
+      import: true,
+      shareScope: 'default',
+      packagePath: key,
+      // Whether the path is set manually
+      manuallyPackagePathSetting: false,
+      generate: true,
+      modulePreload: false
+    }),
+    (value, key) => {
+      value.import = value.import ?? true
+      value.shareScope = value.shareScope || 'default'
+      value.packagePath = value.packagePath || key
+      value.manuallyPackagePathSetting = value.packagePath !== key
+      value.generate = value.generate ?? true
+      value.modulePreload = value.modulePreload ?? false
+      return value
+    }
+  )
+}
+export function parseExposeOptions(
+  options: VitePluginFederationOptions
+): (string | ConfigTypeSet)[] {
+  return parseOptions(
+    options.exposes,
+    (item) => {
+      return {
+        import: item,
+        name: undefined,
+        dontAppendStylesToHead: false
+      }
+    },
+    (item) => ({
+      import: item.import,
+      name: item.name || undefined,
+      dontAppendStylesToHead: item.dontAppendStylesToHead || false
+    })
+  )
+}
+export function createContentHash(path: string): string {
+  const content = readFileSync(path, { encoding: 'utf-8' })
+  return createHash('md5').update(content).digest('hex').toString().slice(0, 8)
+}
+export function parseRemoteOptions(
+  options: VitePluginFederationOptions
+): (string | ConfigTypeSet)[] {
+  return parseOptions(
+    options.remotes ? options.remotes : {},
+    (item) => ({
+      external: Array.isArray(item) ? item : [item],
+      shareScope: options.shareScope || 'default',
+      format: 'esm',
+      from: 'vite',
+      externalType: 'url'
+    }),
+    (item) => ({
+      external: Array.isArray(item.external) ? item.external : [item.external],
+      shareScope: item.shareScope || options.shareScope || 'default',
+      format: item.format || 'esm',
+      from: item.from ?? 'vite',
+      externalType: item.externalType || 'url'
+    })
+  )
+}
+export function parseOptions(
+  options: Exposes | Remotes | Shared | undefined,
+  normalizeSimple: (value: any, key: any) => ConfigTypeSet,
+  normalizeOptions: (value: any, key: any) => ConfigTypeSet
+): (string | ConfigTypeSet)[] {
+  if (!options) {
+    return []
+  }
+  const list: {
+    [index: number]: string | ConfigTypeSet
+  }[] = []
+  const array = (items: (string | ConfigTypeSet)[]) => {
+    for (const item of items) {
+      if (typeof item === 'string') {
+        list.push([item, normalizeSimple(item, item)])
+      } else if (item && typeof item === 'object') {
+        object(item)
+      } else {
+        throw new Error('Unexpected options format')
+      }
+    }
+  }
+  const object = (obj) => {
+    for (const [key, value] of Object.entries(obj)) {
+      if (typeof value === 'string' || Array.isArray(value)) {
+        list.push([key, normalizeSimple(value, key)])
+      } else {
+        list.push([key, normalizeOptions(value, key)])
+      }
+    }
+  }
+  if (Array.isArray(options)) {
+    array(options)
+  } else if (typeof options === 'object') {
+    object(options)
+  } else {
+    throw new Error('Unexpected options format')
+  }
+  return list
+}
+const letterReg = new RegExp('[0-9a-zA-Z]+')
+export function removeNonRegLetter(str: string, reg = letterReg): string {
+  let needUpperCase = false
+  let ret = ''
+  for (const c of str) {
+    if (reg.test(c)) {
+      ret += needUpperCase ? c.toUpperCase() : c
+      needUpperCase = false
+    } else {
+      needUpperCase = true
+    }
+  }
+  return ret
+}
+export function getModuleMarker(value: string, type?: string): string {
+  return type ? `__rf_${type}__${value}` : `__rf_placeholder__${value}`
+}
+export function normalizePath(id: string): string {
+  return posix.normalize(id.replace(/\\/g, '/'))
+}
+export function uniqueArr<T>(arr: T[]): T[] {
+  return Array.from(new Set(arr))
+}
+export function isSameFilepath(src: string, dest: string): boolean {
+  if (!src || !dest) {
+    return false
+  }
+  src = normalizePath(src)
+  dest = normalizePath(dest)
+  const srcExt = parse(src).ext
+  const destExt = parse(dest).ext
+  if (srcExt && destExt && srcExt !== destExt) {
+    return false
+  }
+  if (srcExt) {
+    src = src.slice(0, -srcExt.length)
+  }
+  if (destExt) {
+    dest = dest.slice(0, -destExt.length)
+  }
+  return src === dest
+}
+export type Remote = { id: string; regexp: RegExp; config: RemotesConfig }
+export function createRemotesMap(remotes: Remote[]): string {
+  const createUrl = (remote: Remote) => {
+    const external = remote.config.external[0]
+    const externalType = remote.config.externalType
+    if (externalType === 'promise') {
+      return `()=>${external}`
+    } else {
+      return `'${external}'`
+    }
+  }
+  return `const remotesMap = {
+${remotes
+    .map(
+      (remote) =>
+        `'${remote.id}':{url:${createUrl(remote)},format:'${
+          remote.config.format
+        }',from:'${remote.config.from}'}`
+    )
+    .join(',\n  ')}
+};`
+}
+/**
+ * get file extname from url
+ * @param url
+ */
+export function getFileExtname(url: string): string {
+  const fileNameAndParamArr = normalizePath(url).split('/')
+  const fileNameAndParam = fileNameAndParamArr[fileNameAndParamArr.length - 1]
+  const fileName = fileNameAndParam.split('?')[0]
+  return path.extname(fileName)
+}
+export const REMOTE_FROM_PARAMETER = 'remoteFrom'
+export const NAME_CHAR_REG = new RegExp('[0-9a-zA-Z@_-]+')

package/src/federation/src/utils/semver/compare.ts ADDED Viewed

@@ -0,0 +1,131 @@
+// *****************************************************************************
+// Copyright (C) 2022 Origin.js and others.
+//
+// This program and the accompanying materials are licensed under Mulan PSL v2.
+// You can use this software according to the terms and conditions of the Mulan PSL v2.
+// You may obtain a copy of Mulan PSL v2 at:
+//          http://license.coscl.org.cn/MulanPSL2
+// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+// EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+// MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+// See the Mulan PSL v2 for more details.
+//
+// SPDX-License-Identifier: MulanPSL-2.0
+// *****************************************************************************
+export interface CompareAtom {
+  operator: string
+  version: string
+  major: string
+  minor: string
+  patch: string
+  preRelease?: string[]
+}
+function compareAtom(
+  rangeAtom: string | number,
+  versionAtom: string | number
+): number {
+  rangeAtom = +rangeAtom || rangeAtom
+  versionAtom = +versionAtom || versionAtom
+  if (rangeAtom > versionAtom) {
+    return 1
+  }
+  if (rangeAtom === versionAtom) {
+    return 0
+  }
+  return -1
+}
+function comparePreRelease(
+  rangeAtom: CompareAtom,
+  versionAtom: CompareAtom
+): number {
+  const { preRelease: rangePreRelease } = rangeAtom
+  const { preRelease: versionPreRelease } = versionAtom
+  if (rangePreRelease === undefined && !!versionPreRelease) {
+    return 1
+  }
+  if (!!rangePreRelease && versionPreRelease === undefined) {
+    return -1
+  }
+  if (rangePreRelease === undefined && versionPreRelease === undefined) {
+    return 0
+  }
+  for (let i = 0, n = rangePreRelease!.length; i <= n; i++) {
+    const rangeElement = rangePreRelease![i]
+    const versionElement = versionPreRelease![i]
+    if (rangeElement === versionElement) {
+      continue
+    }
+    if (rangeElement === undefined && versionElement === undefined) {
+      return 0
+    }
+    if (!rangeElement) {
+      return 1
+    }
+    if (!versionElement) {
+      return -1
+    }
+    return compareAtom(rangeElement, versionElement)
+  }
+  return 0
+}
+function compareVersion(
+  rangeAtom: CompareAtom,
+  versionAtom: CompareAtom
+): number {
+  return (
+    compareAtom(rangeAtom.major, versionAtom.major) ||
+    compareAtom(rangeAtom.minor, versionAtom.minor) ||
+    compareAtom(rangeAtom.patch, versionAtom.patch) ||
+    comparePreRelease(rangeAtom, versionAtom)
+  )
+}
+function eq(rangeAtom: CompareAtom, versionAtom: CompareAtom): boolean {
+  return rangeAtom.version === versionAtom.version
+}
+export function compare(
+  rangeAtom: CompareAtom,
+  versionAtom: CompareAtom
+): boolean {
+  switch (rangeAtom.operator) {
+    case '':
+    case '=':
+      return eq(rangeAtom, versionAtom)
+    case '>':
+      return compareVersion(rangeAtom, versionAtom) < 0
+    case '>=':
+      return (
+        eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) < 0
+      )
+    case '<':
+      return compareVersion(rangeAtom, versionAtom) > 0
+    case '<=':
+      return (
+        eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) > 0
+      )
+    case undefined: {
+      // mean * or x -> all versions
+      return true
+    }
+    default:
+      return false
+  }
+}

package/src/federation/src/utils/semver/constants.ts ADDED Viewed

@@ -0,0 +1,46 @@
+// *****************************************************************************
+// Copyright (C) 2022 Origin.js and others.
+//
+// This program and the accompanying materials are licensed under Mulan PSL v2.
+// You can use this software according to the terms and conditions of the Mulan PSL v2.
+// You may obtain a copy of Mulan PSL v2 at:
+//          http://license.coscl.org.cn/MulanPSL2
+// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+// EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+// MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+// See the Mulan PSL v2 for more details.
+//
+// SPDX-License-Identifier: MulanPSL-2.0
+// *****************************************************************************
+// those constants are based on https://www.rubydoc.info/gems/semantic_range/3.0.0/SemanticRange#BUILDIDENTIFIER-constant
+const buildIdentifier = '[0-9A-Za-z-]+'
+const build = `(?:\\+(${buildIdentifier}(?:\\.${buildIdentifier})*))`
+const numericIdentifier = '0|[1-9]\\d*'
+const numericIdentifierLoose = '[0-9]+'
+const nonNumericIdentifier = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'
+const preReleaseIdentifierLoose = `(?:${numericIdentifierLoose}|${nonNumericIdentifier})`
+const preReleaseLoose = `(?:-?(${preReleaseIdentifierLoose}(?:\\.${preReleaseIdentifierLoose})*))`
+const preReleaseIdentifier = `(?:${numericIdentifier}|${nonNumericIdentifier})`
+const preRelease = `(?:-(${preReleaseIdentifier}(?:\\.${preReleaseIdentifier})*))`
+const xRangeIdentifier = `${numericIdentifier}|x|X|\\*`
+const xRangePlain = `[v=\\s]*(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:${preRelease})?${build}?)?)?`
+export const hyphenRange = `^\\s*(${xRangePlain})\\s+-\\s+(${xRangePlain})\\s*$`
+const mainVersionLoose = `(${numericIdentifierLoose})\\.(${numericIdentifierLoose})\\.(${numericIdentifierLoose})`
+const loosePlain = `[v=\\s]*${mainVersionLoose}${preReleaseLoose}?${build}?`
+const gtlt = '((?:<|>)?=?)'
+export const comparatorTrim = `(\\s*)${gtlt}\\s*(${loosePlain}|${xRangePlain})`
+const loneTilde = '(?:~>?)'
+export const tildeTrim = `(\\s*)${loneTilde}\\s+`
+const loneCaret = '(?:\\^)'
+export const caretTrim = `(\\s*)${loneCaret}\\s+`
+export const star = '(<|>)?=?\\s*\\*'
+export const caret = `^${loneCaret}${xRangePlain}$`
+const mainVersion = `(${numericIdentifier})\\.(${numericIdentifier})\\.(${numericIdentifier})`
+const fullPlain = `v?${mainVersion}${preRelease}?${build}?`
+export const tilde = `^${loneTilde}${xRangePlain}$`
+export const xRange = `^${gtlt}\\s*${xRangePlain}$`
+export const comparator = `^${gtlt}\\s*(${fullPlain})$|^$`
+// copy from semver package
+export const gte0 = '^\\s*>=\\s*0.0.0\\s*$'