betterstart-cli 0.0.100 → 0.0.101

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-highlight-color-options.ts

@@ -0,0 +1,68 @@
+import type { ContentEditorHighlightColor } from '@admin/utils/editor/content-editor-highlight-color'
+import type { ContentEditorHighlightColorOption } from '@admin/utils/editor/content-editor-highlight-color-option'
+
+export const CONTENT_EDITOR_HIGHLIGHT_COLOR_OPTIONS: Record<
+  ContentEditorHighlightColor,
+  ContentEditorHighlightColorOption
+> = {
+  default: {
+    label: 'Default background',
+    value: 'var(--tt-bg-color)',
+    colorValue: '#ffffff',
+    border: 'var(--tt-bg-color-contrast)'
+  },
+  gray: {
+    label: 'Gray background',
+    value: 'var(--tt-color-highlight-gray)',
+    colorValue: '#f8f8f7',
+    border: 'var(--tt-color-highlight-gray-contrast)'
+  },
+  brown: {
+    label: 'Brown background',
+    value: 'var(--tt-color-highlight-brown)',
+    colorValue: '#f4eeee',
+    border: 'var(--tt-color-highlight-brown-contrast)'
+  },
+  orange: {
+    label: 'Orange background',
+    value: 'var(--tt-color-highlight-orange)',
+    colorValue: '#fbecdd',
+    border: 'var(--tt-color-highlight-orange-contrast)'
+  },
+  yellow: {
+    label: 'Yellow background',
+    value: 'var(--tt-color-highlight-yellow)',
+    colorValue: '#fef9c3',
+    border: 'var(--tt-color-highlight-yellow-contrast)'
+  },
+  green: {
+    label: 'Green background',
+    value: 'var(--tt-color-highlight-green)',
+    colorValue: '#dcfce7',
+    border: 'var(--tt-color-highlight-green-contrast)'
+  },
+  blue: {
+    label: 'Blue background',
+    value: 'var(--tt-color-highlight-blue)',
+    colorValue: '#e0f2fe',
+    border: 'var(--tt-color-highlight-blue-contrast)'
+  },
+  purple: {
+    label: 'Purple background',
+    value: 'var(--tt-color-highlight-purple)',
+    colorValue: '#f3e8ff',
+    border: 'var(--tt-color-highlight-purple-contrast)'
+  },
+  pink: {
+    label: 'Pink background',
+    value: 'var(--tt-color-highlight-pink)',
+    colorValue: '#fcf1f6',
+    border: 'var(--tt-color-highlight-pink-contrast)'
+  },
+  red: {
+    label: 'Red background',
+    value: 'var(--tt-color-highlight-red)',
+    colorValue: '#ffe4e6',
+    border: 'var(--tt-color-highlight-red-contrast)'
+  }
+}

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-highlight-color.ts

@@ -0,0 +1,3 @@
+import { CONTENT_EDITOR_HIGHLIGHT_COLORS } from '@admin/utils/editor/content-editor-highlight-colors'
+
+export type ContentEditorHighlightColor = (typeof CONTENT_EDITOR_HIGHLIGHT_COLORS)[number]

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-highlight-colors.ts

@@ -0,0 +1,12 @@
+export const CONTENT_EDITOR_HIGHLIGHT_COLORS = [
+  'default',
+  'gray',
+  'brown',
+  'orange',
+  'yellow',
+  'green',
+  'blue',
+  'purple',
+  'pink',
+  'red'
+] as const

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-highlight.ts

@@ -0,0 +1,33 @@
+'use client'
+
+import { getContentEditorHighlightColorName } from '@admin/utils/editor/get-content-editor-highlight-color-name'
+import { getContentEditorHighlightColorValue } from '@admin/utils/editor/get-content-editor-highlight-color-value'
+import { isContentEditorHighlightColor } from '@admin/utils/editor/is-content-editor-highlight-color'
+import { Highlight } from '@tiptap/extension-highlight'
+
+export const ContentEditorHighlight = Highlight.extend({
+  parseHTML() {
+    return [
+      {
+        tag: 'span[data-highlight-color]',
+        getAttrs: (element) => {
+          if (!(element instanceof HTMLElement)) return false
+
+          const color = element.getAttribute('data-highlight-color')
+          if (!color || !isContentEditorHighlightColor(color)) return false
+
+          return {
+            color: getContentEditorHighlightColorValue(color)
+          }
+        }
+      }
+    ]
+  },
+
+  renderMarkdown: (node, helpers) => {
+    const color = getContentEditorHighlightColorName(node.attrs?.color)
+    return `<span data-highlight-color="${color}">${helpers.renderChildren(node)}</span>`
+  },
+  parseMarkdown: null as never,
+  markdownTokenizer: null as never
+})

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-inline-math-delimiter.ts

@@ -0,0 +1 @@
+export type ContentEditorInlineMathDelimiter = '$' | '\\('

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-inline-math.ts

@@ -0,0 +1,105 @@
+'use client'
+
+import { findInlineMathStart } from '@admin/utils/editor/find-inline-math-start'
+import { getInlineMathDelimiter } from '@admin/utils/editor/get-inline-math-delimiter'
+import { getRawContentToken } from '@admin/utils/editor/get-raw-content-token'
+import { getStringAttr } from '@admin/utils/editor/get-string-attr'
+import { InlineMathNodeView } from '@admin/utils/editor/inline-math-node-view'
+import { matchInlineMath } from '@admin/utils/editor/match-inline-math'
+import { mergeAttributes, Node as TiptapNode } from '@tiptap/core'
+
+export const ContentEditorInlineMath = TiptapNode.create({
+  name: 'inlineMath',
+  group: 'inline',
+  inline: true,
+  atom: true,
+  selectable: true,
+
+  addAttributes() {
+    return {
+      raw: {
+        default: ''
+      },
+      delimiter: {
+        default: '$'
+      }
+    }
+  },
+
+  parseHTML() {
+    return [
+      {
+        tag: 'span[data-content-editor-inline-math]',
+        getAttrs: (element) => {
+          if (!(element instanceof HTMLElement)) return false
+
+          return {
+            raw: element.dataset.raw ?? element.textContent ?? '',
+            delimiter: element.dataset.delimiter === '\\(' ? '\\(' : '$'
+          }
+        }
+      }
+    ]
+  },
+
+  renderHTML({ HTMLAttributes, node }) {
+    const raw = getStringAttr(node.attrs.raw)
+    const delimiter = getInlineMathDelimiter(node.attrs.delimiter)
+
+    return [
+      'span',
+      mergeAttributes(HTMLAttributes, {
+        'data-content-editor-inline-math': '',
+        'data-raw': raw,
+        'data-delimiter': delimiter
+      }),
+      raw
+    ]
+  },
+
+  parseMarkdown: (token) => {
+    const mathToken = getRawContentToken(token)
+
+    return {
+      type: 'inlineMath',
+      attrs: {
+        raw: mathToken.text ?? mathToken.raw ?? '',
+        delimiter: getInlineMathDelimiter(mathToken.delimiter)
+      }
+    }
+  },
+
+  renderMarkdown: (node) => {
+    const raw = getStringAttr(node.attrs?.raw)
+    const delimiter = getInlineMathDelimiter(node.attrs?.delimiter)
+
+    if (delimiter === '\\(') {
+      return `\\(${raw}\\)`
+    }
+
+    return `$${raw}$`
+  },
+
+  markdownTokenizer: {
+    name: 'inlineMath',
+    level: 'inline',
+    start: findInlineMathStart,
+    tokenize(src) {
+      const match = matchInlineMath(src)
+      if (!match) return undefined
+
+      return {
+        type: 'inlineMath',
+        raw: match.raw,
+        text: match.text,
+        delimiter: match.delimiter
+      }
+    }
+  },
+
+  addNodeView() {
+    return ({ node }) => {
+      return new InlineMathNodeView(node)
+    }
+  }
+})

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-keyboard.ts

@@ -0,0 +1,5 @@
+'use client'
+
+import { createHtmlMark } from '@admin/utils/editor/create-html-mark'
+
+export const ContentEditorKeyboard = createHtmlMark('keyboard', 'kbd')

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-math-kind.ts

@@ -0,0 +1 @@
+export type ContentEditorMathKind = 'inline' | 'display'

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-math-value.ts

@@ -0,0 +1,9 @@
+import type { ContentEditorInlineMathDelimiter } from '@admin/utils/editor/content-editor-inline-math-delimiter'
+import type { ContentEditorMathKind } from '@admin/utils/editor/content-editor-math-kind'
+
+export interface ContentEditorMathValue {
+  delimiter?: ContentEditorInlineMathDelimiter
+  kind: ContentEditorMathKind
+  markdown: string
+  raw: string
+}

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-media-placeholder-node.ts

@@ -0,0 +1 @@
+export const CONTENT_EDITOR_MEDIA_PLACEHOLDER_NODE = 'mediaGalleryPlaceholder'

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-media-shortcut-key.ts

@@ -0,0 +1 @@
+export const CONTENT_EDITOR_MEDIA_SHORTCUT_KEY = 'mod+shift+i'

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-mode.ts

@@ -0,0 +1 @@
+export type ContentEditorMode = 'rich' | 'source'

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-raw-content-block.ts

@@ -0,0 +1,95 @@
+'use client'
+
+import { findRawContentStart } from '@admin/utils/editor/find-raw-content-start'
+import { getRawContentKind } from '@admin/utils/editor/get-raw-content-kind'
+import { getRawContentToken } from '@admin/utils/editor/get-raw-content-token'
+import { getStringAttr } from '@admin/utils/editor/get-string-attr'
+import { matchRawContentBlock } from '@admin/utils/editor/match-raw-content-block'
+import { RawContentBlockNodeView } from '@admin/utils/editor/raw-content-block-node-view'
+import { mergeAttributes, Node as TiptapNode } from '@tiptap/core'
+
+export const ContentEditorRawContentBlock = TiptapNode.create({
+  name: 'rawContentBlock',
+  group: 'block',
+  atom: true,
+  selectable: true,
+
+  addAttributes() {
+    return {
+      kind: {
+        default: 'html'
+      },
+      raw: {
+        default: ''
+      }
+    }
+  },
+
+  parseHTML() {
+    return [
+      {
+        tag: 'div[data-content-editor-raw-block]',
+        getAttrs: (element) => {
+          if (!(element instanceof HTMLElement)) return false
+
+          return {
+            kind: getRawContentKind(element.dataset.contentEditorRawBlock),
+            raw: element.dataset.raw ?? ''
+          }
+        }
+      }
+    ]
+  },
+
+  renderHTML({ HTMLAttributes, node }) {
+    const raw = getStringAttr(node.attrs.raw)
+    const kind = getRawContentKind(node.attrs.kind)
+
+    return [
+      'div',
+      mergeAttributes(HTMLAttributes, {
+        'data-content-editor-raw-block': kind,
+        'data-raw': raw
+      })
+    ]
+  },
+
+  parseMarkdown: (token) => {
+    const rawToken = getRawContentToken(token)
+
+    return {
+      type: 'rawContentBlock',
+      attrs: {
+        kind: getRawContentKind(rawToken.kind),
+        raw: rawToken.raw ?? rawToken.text ?? ''
+      }
+    }
+  },
+
+  renderMarkdown: (node) => {
+    return getStringAttr(node.attrs?.raw)
+  },
+
+  markdownTokenizer: {
+    name: 'rawContentBlock',
+    level: 'block',
+    start: findRawContentStart,
+    tokenize(src) {
+      const match = matchRawContentBlock(src)
+      if (!match) return undefined
+
+      return {
+        type: 'rawContentBlock',
+        raw: match.raw,
+        text: match.raw,
+        kind: match.kind
+      }
+    }
+  },
+
+  addNodeView() {
+    return ({ getPos, node, view }) => {
+      return new RawContentBlockNodeView({ getPos, node, view })
+    }
+  }
+})

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-selected-math.ts

@@ -0,0 +1,12 @@
+import type { ContentEditorInlineMathDelimiter } from '@admin/utils/editor/content-editor-inline-math-delimiter'
+import type { ContentEditorMathKind } from '@admin/utils/editor/content-editor-math-kind'
+import type { Node as PMNode } from '@tiptap/pm/model'
+
+export interface ContentEditorSelectedMath {
+  delimiter?: ContentEditorInlineMathDelimiter
+  kind: ContentEditorMathKind
+  node: PMNode
+  pos: number
+  raw: string
+  value: string
+}

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-selection-request.ts

@@ -0,0 +1,4 @@
+export interface ContentEditorSelectionRequest {
+  id: number
+  offset: number
+}

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-subscript.ts

@@ -0,0 +1,5 @@
+'use client'
+
+import { createHtmlMark } from '@admin/utils/editor/create-html-mark'
+
+export const ContentEditorSubscript = createHtmlMark('subscript', 'sub')

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-superscript.ts

@@ -0,0 +1,5 @@
+'use client'
+
+import { createHtmlMark } from '@admin/utils/editor/create-html-mark'
+
+export const ContentEditorSuperscript = createHtmlMark('superscript', 'sup')

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-table-alignment.ts

@@ -0,0 +1 @@
+export type ContentEditorTableAlignment = 'left' | 'center' | 'right'

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor-underline.ts

@@ -0,0 +1,26 @@
+'use client'
+
+import { Mark, mergeAttributes } from '@tiptap/core'
+
+export const ContentEditorUnderline = Mark.create({
+  name: 'underline',
+
+  parseHTML() {
+    return [{ tag: 'u' }]
+  },
+
+  renderHTML({ HTMLAttributes }) {
+    return ['u', mergeAttributes(HTMLAttributes), 0]
+  },
+
+  markdownOptions: {
+    htmlReopen: {
+      open: '<u>',
+      close: '</u>'
+    }
+  },
+
+  renderMarkdown: (node, helpers) => {
+    return `<u>${helpers.renderChildren(node)}</u>`
+  }
+})

package/dist/assets/adapters/next/templates/init/utils/editor/create-content-editor-table-node.ts

@@ -0,0 +1,27 @@
+import type { JSONContent } from '@tiptap/core'
+import { DEFAULT_CONTENT_EDITOR_TABLE_COLS } from '@admin/utils/editor/default-content-editor-table-cols'
+import { DEFAULT_CONTENT_EDITOR_TABLE_ROWS } from '@admin/utils/editor/default-content-editor-table-rows'
+
+export function createContentEditorTableNode(
+  rows: number = DEFAULT_CONTENT_EDITOR_TABLE_ROWS,
+  cols: number = DEFAULT_CONTENT_EDITOR_TABLE_COLS
+): JSONContent {
+  const rowCount = Math.max(2, Math.floor(rows))
+  const colCount = Math.max(1, Math.floor(cols))
+
+  return {
+    type: 'table',
+    content: Array.from({ length: rowCount }, (_, rowIndex) => ({
+      type: 'tableRow',
+      content: Array.from({ length: colCount }, (_, colIndex) => ({
+        type: rowIndex === 0 ? 'tableHeader' : 'tableCell',
+        content: [
+          {
+            type: 'paragraph',
+            content: rowIndex === 0 ? [{ type: 'text', text: `Header ${colIndex + 1}` }] : []
+          }
+        ]
+      }))
+    }))
+  }
+}

package/dist/assets/adapters/next/templates/init/utils/editor/create-html-mark.ts

@@ -0,0 +1,28 @@
+'use client'
+
+import { Mark, mergeAttributes } from '@tiptap/core'
+
+export function createHtmlMark(name: string, tag: 'kbd' | 'sub' | 'sup') {
+  return Mark.create({
+    name,
+
+    parseHTML() {
+      return [{ tag }]
+    },
+
+    renderHTML({ HTMLAttributes }) {
+      return [tag, mergeAttributes(HTMLAttributes), 0]
+    },
+
+    markdownOptions: {
+      htmlReopen: {
+        open: `<${tag}>`,
+        close: `</${tag}>`
+      }
+    },
+
+    renderMarkdown: (node, helpers) => {
+      return `<${tag}>${helpers.renderChildren(node)}</${tag}>`
+    }
+  })
+}

package/dist/assets/adapters/next/templates/init/utils/editor/create-markdown-image-text.ts

@@ -0,0 +1,5 @@
+import type { MarkdownImageUploadResult } from '@admin/utils/editor/markdown-image-upload-result'
+
+export function createMarkdownImageText(images: MarkdownImageUploadResult[]): string {
+  return images.map((img) => `![${img.filename}](${img.url})`).join('\n')
+}

package/dist/assets/adapters/next/templates/init/utils/editor/create-markdown-plain-text-offset-map.ts

@@ -0,0 +1,126 @@
+import { matchCodeFenceStart } from '@admin/utils/editor/match-code-fence-start'
+import { matchHtmlMarkSyntax } from '@admin/utils/editor/match-html-mark-syntax'
+import { matchMarkdownBlockPrefix } from '@admin/utils/editor/match-markdown-block-prefix'
+import { matchMarkdownMarkSyntax } from '@admin/utils/editor/match-markdown-mark-syntax'
+
+interface MarkdownPlainTextOffsetMap {
+  markdownToPlainOffsets: number[]
+  plainToMarkdownOffsets: number[]
+}
+
+export function createMarkdownPlainTextOffsetMap(markdown: string): MarkdownPlainTextOffsetMap {
+  const markdownToPlainOffsets = new Array<number>(markdown.length + 1).fill(0)
+  const plainToMarkdownOffsets = [0]
+  let index = 0
+  let plainOffset = 0
+
+  const skipUntil = (nextIndex: number) => {
+    const safeNextIndex = Math.max(index, Math.min(nextIndex, markdown.length))
+
+    while (index < safeNextIndex) {
+      markdownToPlainOffsets[index] = plainOffset
+      index++
+      markdownToPlainOffsets[index] = plainOffset
+    }
+  }
+
+  const consumeVisibleUntil = (nextIndex: number) => {
+    const safeNextIndex = Math.max(index, Math.min(nextIndex, markdown.length))
+
+    while (index < safeNextIndex) {
+      consumeVisibleCharacter()
+    }
+  }
+
+  const consumeVisibleCharacter = () => {
+    const character = markdown[index]
+
+    if (character === '\r') {
+      skipUntil(index + 1)
+      return
+    }
+
+    if (character === '\n') {
+      const runStart = index
+      let runEnd = index + 1
+
+      while (runEnd < markdown.length && markdown[runEnd] === '\n') {
+        runEnd++
+      }
+
+      markdownToPlainOffsets[runStart] = plainOffset
+      plainOffset++
+      plainToMarkdownOffsets[plainOffset] = runEnd
+
+      for (let offset = runStart + 1; offset <= runEnd; offset++) {
+        markdownToPlainOffsets[offset] = plainOffset
+      }
+
+      index = runEnd
+      return
+    }
+
+    markdownToPlainOffsets[index] = plainOffset
+    plainOffset++
+    index++
+    plainToMarkdownOffsets[plainOffset] = index
+    markdownToPlainOffsets[index] = plainOffset
+  }
+
+  while (index < markdown.length) {
+    const imageMatch = /^!\[([^\]]*)\]\([^)]+\)/.exec(markdown.slice(index))
+    if (imageMatch) {
+      const textStart = index + 2
+      const textEnd = textStart + imageMatch[1].length
+      skipUntil(textStart)
+      consumeVisibleUntil(textEnd)
+      skipUntil(index + imageMatch[0].length)
+      continue
+    }
+
+    const linkMatch = /^\[([^\]]+)\]\([^)]+\)/.exec(markdown.slice(index))
+    if (linkMatch) {
+      const textStart = index + 1
+      const textEnd = textStart + linkMatch[1].length
+      skipUntil(textStart)
+      consumeVisibleUntil(textEnd)
+      skipUntil(index + linkMatch[0].length)
+      continue
+    }
+
+    const codeFenceEnd = matchCodeFenceStart(markdown, index)
+    if (codeFenceEnd !== null) {
+      skipUntil(codeFenceEnd)
+      continue
+    }
+
+    const blockPrefixEnd = matchMarkdownBlockPrefix(markdown, index)
+    if (blockPrefixEnd !== null) {
+      skipUntil(blockPrefixEnd)
+      continue
+    }
+
+    const markSyntaxEnd = matchMarkdownMarkSyntax(markdown, index)
+    if (markSyntaxEnd !== null) {
+      skipUntil(markSyntaxEnd)
+      continue
+    }
+
+    const htmlMarkSyntaxEnd = matchHtmlMarkSyntax(markdown, index)
+    if (htmlMarkSyntaxEnd !== null) {
+      skipUntil(htmlMarkSyntaxEnd)
+      continue
+    }
+
+    if (markdown[index] === '\\' && index + 1 < markdown.length) {
+      skipUntil(index + 1)
+      consumeVisibleCharacter()
+      continue
+    }
+
+    consumeVisibleCharacter()
+  }
+
+  markdownToPlainOffsets[markdown.length] = plainOffset
+  return { markdownToPlainOffsets, plainToMarkdownOffsets }
+}

package/dist/assets/adapters/next/templates/init/utils/editor/create-markdown-table-text.ts

@@ -0,0 +1,15 @@
+export function createMarkdownTableText(rows: number, cols: number): string {
+  const rowCount = Math.max(2, Math.floor(rows))
+  const colCount = Math.max(1, Math.floor(cols))
+  const headerCells = Array.from({ length: colCount }, (_, index) => `Header ${index + 1}`)
+  const dividerCells = Array.from({ length: colCount }, () => '---')
+  const bodyRows = Array.from({ length: rowCount - 1 }, () =>
+    Array.from({ length: colCount }, () => '').join(' | ')
+  )
+
+  return [
+    `| ${headerCells.join(' | ')} |`,
+    `| ${dividerCells.join(' | ')} |`,
+    ...bodyRows.map((row) => `| ${row} |`)
+  ].join('\n')
+}

package/dist/assets/adapters/next/templates/init/utils/editor/create-markdown-text-from-url.ts

@@ -0,0 +1,6 @@
+import { createMarkdownImageText } from '@admin/utils/editor/create-markdown-image-text'
+import { getMediaLabel } from '@admin/utils/editor/get-media-label'
+
+export function createMarkdownTextFromUrl(url: string): string {
+  return createMarkdownImageText([{ url, filename: getMediaLabel(url) }])
+}

package/dist/assets/adapters/next/templates/init/utils/editor/default-content-editor-table-cols.ts

@@ -0,0 +1 @@
+export const DEFAULT_CONTENT_EDITOR_TABLE_COLS = 3

package/dist/assets/adapters/next/templates/init/utils/editor/default-content-editor-table-rows.ts

@@ -0,0 +1 @@
+export const DEFAULT_CONTENT_EDITOR_TABLE_ROWS = 3

package/dist/assets/adapters/next/templates/init/utils/editor/doc-position-from-plain-text-offset.ts

@@ -0,0 +1,27 @@
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
+import { getPlainTextOffsetBeforeDocPosition } from '@admin/utils/editor/get-plain-text-offset-before-doc-position'
+import { TextSelection } from '@tiptap/pm/state'
+
+export function docPositionFromPlainTextOffset(doc: ProseMirrorNode, textOffset: number): number {
+  const minPosition = TextSelection.atStart(doc).from
+  const maxPosition = TextSelection.atEnd(doc).to
+  const safeOffset = Math.max(0, textOffset)
+
+  if (safeOffset === 0) return minPosition
+
+  let low = minPosition
+  let high = maxPosition
+
+  while (low < high) {
+    const midpoint = Math.floor((low + high) / 2)
+    const currentOffset = getPlainTextOffsetBeforeDocPosition(doc, midpoint)
+
+    if (currentOffset < safeOffset) {
+      low = midpoint + 1
+    } else {
+      high = midpoint
+    }
+  }
+
+  return Math.max(minPosition, Math.min(low, maxPosition))
+}