@pgcorp/ui-kit 0.10.0 → 0.10.2

package/src/internal/diffEngine.ts

@@ -1,464 +0,0 @@
-import type {
-  SDiffComputationOptions,
-  SDiffGap,
-  SDiffHunk,
-  SDiffLine,
-  SDiffLineBreak,
-  SDiffLineKind,
-  SDiffLineSide,
-  SDiffResult,
-  SDiffSource,
-  SDiffSourceSnapshot,
-} from '../components/shared/data-display/diff'
-
-interface DiffToken {
-  readonly text: string
-  readonly lineBreak: SDiffLineBreak
-}
-
-interface DiffOperation {
-  readonly kind: SDiffLineKind
-  readonly beforeIndex?: number
-  readonly afterIndex?: number
-}
-
-export type DiffCancellationProbe = () => boolean
-
-export class DiffEngineCancelledError extends Error {
-  constructor() {
-    super('Diff computation was cancelled.')
-    this.name = 'DiffEngineCancelledError'
-  }
-}
-
-const CANCELLATION_CHECK_INTERVAL = 1024
-
-class CancellationCheckpoint {
-  private operations = 0
-
-  constructor(private readonly isCancelled: DiffCancellationProbe | undefined) {}
-
-  check(force = false): void {
-    this.operations += 1
-    if (!force && this.operations % CANCELLATION_CHECK_INTERVAL !== 0) return
-    if (this.isCancelled?.() === true) throw new DiffEngineCancelledError()
-  }
-}
-
-function tokenize(text: string): readonly DiffToken[] {
-  if (text.length === 0) return Object.freeze([])
-  const tokens: DiffToken[] = []
-  let start = 0
-  for (let index = 0; index < text.length; index += 1) {
-    if (text[index] !== '\n') continue
-    const hasCarriageReturn = index > start && text[index - 1] === '\r'
-    tokens.push(Object.freeze({
-      text: text.slice(start, hasCarriageReturn ? index - 1 : index),
-      lineBreak: hasCarriageReturn ? 'crlf' : 'lf',
-    }))
-    start = index + 1
-  }
-  if (start < text.length) {
-    tokens.push(Object.freeze({ text: text.slice(start), lineBreak: 'none' }))
-  }
-  return Object.freeze(tokens)
-}
-
-function tokensEqual(left: DiffToken, right: DiffToken): boolean {
-  return left.text === right.text && left.lineBreak === right.lineBreak
-}
-
-function findToken(
-  tokens: readonly DiffToken[],
-  start: number,
-  end: number,
-  target: DiffToken,
-  checkpoint: CancellationCheckpoint,
-): number {
-  for (let index = start; index < end; index += 1) {
-    checkpoint.check()
-    if (tokensEqual(tokens[index], target)) return index
-  }
-  return -1
-}
-
-function emitRemoved(operations: DiffOperation[], start: number, end: number): void {
-  for (let index = start; index < end; index += 1) {
-    operations.push({ kind: 'removed', beforeIndex: index })
-  }
-}
-
-function emitAdded(operations: DiffOperation[], start: number, end: number): void {
-  for (let index = start; index < end; index += 1) {
-    operations.push({ kind: 'added', afterIndex: index })
-  }
-}
-
-function emitUnchanged(
-  operations: DiffOperation[],
-  beforeStart: number,
-  afterStart: number,
-  length: number,
-): void {
-  for (let offset = 0; offset < length; offset += 1) {
-    operations.push({
-      kind: 'unchanged',
-      beforeIndex: beforeStart + offset,
-      afterIndex: afterStart + offset,
-    })
-  }
-}
-
-interface BisectSplit {
-  readonly before: number
-  readonly after: number
-}
-
-function findBisectSplit(
-  before: readonly DiffToken[],
-  beforeStart: number,
-  beforeEnd: number,
-  after: readonly DiffToken[],
-  afterStart: number,
-  afterEnd: number,
-  checkpoint: CancellationCheckpoint,
-): BisectSplit | null {
-  const beforeLength = beforeEnd - beforeStart
-  const afterLength = afterEnd - afterStart
-  const maxDistance = Math.ceil((beforeLength + afterLength) / 2)
-  const vectorOffset = maxDistance
-  const vectorLength = maxDistance * 2 + 1
-  const forward = new Int32Array(vectorLength)
-  const reverse = new Int32Array(vectorLength)
-  forward.fill(-1)
-  reverse.fill(-1)
-  forward[vectorOffset + 1] = 0
-  reverse[vectorOffset + 1] = 0
-  const delta = beforeLength - afterLength
-  const frontOverlap = delta % 2 !== 0
-  let forwardStart = 0
-  let forwardEnd = 0
-  let reverseStart = 0
-  let reverseEnd = 0
-
-  for (let distance = 0; distance < maxDistance; distance += 1) {
-    checkpoint.check(true)
-    for (
-      let diagonal = -distance + forwardStart;
-      diagonal <= distance - forwardEnd;
-      diagonal += 2
-    ) {
-      const vectorIndex = vectorOffset + diagonal
-      let beforeOffset = diagonal === -distance
-        || (diagonal !== distance && forward[vectorIndex - 1] < forward[vectorIndex + 1])
-        ? forward[vectorIndex + 1]
-        : forward[vectorIndex - 1] + 1
-      let afterOffset = beforeOffset - diagonal
-      while (
-        beforeOffset < beforeLength
-        && afterOffset < afterLength
-        && tokensEqual(before[beforeStart + beforeOffset], after[afterStart + afterOffset])
-      ) {
-        checkpoint.check()
-        beforeOffset += 1
-        afterOffset += 1
-      }
-      forward[vectorIndex] = beforeOffset
-      if (beforeOffset > beforeLength) forwardEnd += 2
-      else if (afterOffset > afterLength) forwardStart += 2
-      else if (frontOverlap) {
-        const reverseDiagonal = delta - diagonal
-        const reverseIndex = vectorOffset + reverseDiagonal
-        if (
-          reverseIndex >= 0
-          && reverseIndex < vectorLength
-          && reverse[reverseIndex] !== -1
-          && beforeOffset >= beforeLength - reverse[reverseIndex]
-        ) {
-          return {
-            before: beforeStart + beforeOffset,
-            after: afterStart + afterOffset,
-          }
-        }
-      }
-    }
-
-    for (
-      let diagonal = -distance + reverseStart;
-      diagonal <= distance - reverseEnd;
-      diagonal += 2
-    ) {
-      const vectorIndex = vectorOffset + diagonal
-      let beforeOffset = diagonal === -distance
-        || (diagonal !== distance && reverse[vectorIndex - 1] < reverse[vectorIndex + 1])
-        ? reverse[vectorIndex + 1]
-        : reverse[vectorIndex - 1] + 1
-      let afterOffset = beforeOffset - diagonal
-      while (
-        beforeOffset < beforeLength
-        && afterOffset < afterLength
-        && tokensEqual(before[beforeEnd - beforeOffset - 1], after[afterEnd - afterOffset - 1])
-      ) {
-        checkpoint.check()
-        beforeOffset += 1
-        afterOffset += 1
-      }
-      reverse[vectorIndex] = beforeOffset
-      if (beforeOffset > beforeLength) reverseEnd += 2
-      else if (afterOffset > afterLength) reverseStart += 2
-      else if (!frontOverlap) {
-        const forwardDiagonal = delta - diagonal
-        const forwardIndex = vectorOffset + forwardDiagonal
-        if (
-          forwardIndex >= 0
-          && forwardIndex < vectorLength
-          && forward[forwardIndex] !== -1
-          && forward[forwardIndex] >= beforeLength - beforeOffset
-        ) {
-          const splitBefore = beforeStart + forward[forwardIndex]
-          return {
-            before: splitBefore,
-            after: afterStart + splitBefore - beforeStart - forwardDiagonal,
-          }
-        }
-      }
-    }
-  }
-  return null
-}
-
-function diffRange(
-  before: readonly DiffToken[],
-  beforeStartValue: number,
-  beforeEndValue: number,
-  after: readonly DiffToken[],
-  afterStartValue: number,
-  afterEndValue: number,
-  operations: DiffOperation[],
-  checkpoint: CancellationCheckpoint,
-): void {
-  checkpoint.check(true)
-  let beforeStart = beforeStartValue
-  let afterStart = afterStartValue
-  while (
-    beforeStart < beforeEndValue
-    && afterStart < afterEndValue
-    && tokensEqual(before[beforeStart], after[afterStart])
-  ) {
-    checkpoint.check()
-    operations.push({ kind: 'unchanged', beforeIndex: beforeStart, afterIndex: afterStart })
-    beforeStart += 1
-    afterStart += 1
-  }
-
-  let beforeEnd = beforeEndValue
-  let afterEnd = afterEndValue
-  let suffixLength = 0
-  while (
-    beforeStart < beforeEnd
-    && afterStart < afterEnd
-    && tokensEqual(before[beforeEnd - 1], after[afterEnd - 1])
-  ) {
-    checkpoint.check()
-    beforeEnd -= 1
-    afterEnd -= 1
-    suffixLength += 1
-  }
-
-  const beforeLength = beforeEnd - beforeStart
-  const afterLength = afterEnd - afterStart
-  if (beforeLength === 0) emitAdded(operations, afterStart, afterEnd)
-  else if (afterLength === 0) emitRemoved(operations, beforeStart, beforeEnd)
-  else if (beforeLength === 1) {
-    const match = findToken(after, afterStart, afterEnd, before[beforeStart], checkpoint)
-    if (match === -1) {
-      emitRemoved(operations, beforeStart, beforeEnd)
-      emitAdded(operations, afterStart, afterEnd)
-    } else {
-      emitAdded(operations, afterStart, match)
-      emitUnchanged(operations, beforeStart, match, 1)
-      emitAdded(operations, match + 1, afterEnd)
-    }
-  } else if (afterLength === 1) {
-    const match = findToken(before, beforeStart, beforeEnd, after[afterStart], checkpoint)
-    if (match === -1) {
-      emitRemoved(operations, beforeStart, beforeEnd)
-      emitAdded(operations, afterStart, afterEnd)
-    } else {
-      emitRemoved(operations, beforeStart, match)
-      emitUnchanged(operations, match, afterStart, 1)
-      emitRemoved(operations, match + 1, beforeEnd)
-    }
-  } else {
-    const split = findBisectSplit(
-      before,
-      beforeStart,
-      beforeEnd,
-      after,
-      afterStart,
-      afterEnd,
-      checkpoint,
-    )
-    if (
-      split === null
-      || (split.before === beforeStart && split.after === afterStart)
-      || (split.before === beforeEnd && split.after === afterEnd)
-    ) {
-      emitRemoved(operations, beforeStart, beforeEnd)
-      emitAdded(operations, afterStart, afterEnd)
-    } else {
-      diffRange(before, beforeStart, split.before, after, afterStart, split.after, operations, checkpoint)
-      diffRange(before, split.before, beforeEnd, after, split.after, afterEnd, operations, checkpoint)
-    }
-  }
-
-  emitUnchanged(operations, beforeEnd, afterEnd, suffixLength)
-}
-
-function createLineSide(token: DiffToken, lineNumber: number): SDiffLineSide {
-  return Object.freeze({ lineNumber, text: token.text, lineBreak: token.lineBreak })
-}
-
-function buildLines(
-  before: readonly DiffToken[],
-  after: readonly DiffToken[],
-  operations: readonly DiffOperation[],
-): readonly SDiffLine[] {
-  return Object.freeze(operations.map((operation) => {
-    const beforeIndex = operation.beforeIndex
-    const afterIndex = operation.afterIndex
-    const beforeSide = beforeIndex === undefined
-      ? undefined
-      : createLineSide(before[beforeIndex], beforeIndex + 1)
-    const afterSide = afterIndex === undefined
-      ? undefined
-      : createLineSide(after[afterIndex], afterIndex + 1)
-    const beforeCoordinate = beforeIndex === undefined ? '-' : String(beforeIndex + 1)
-    const afterCoordinate = afterIndex === undefined ? '-' : String(afterIndex + 1)
-    return Object.freeze({
-      id: `line:${operation.kind}:${beforeCoordinate}:${afterCoordinate}`,
-      kind: operation.kind,
-      ...(beforeSide === undefined ? {} : { before: beforeSide }),
-      ...(afterSide === undefined ? {} : { after: afterSide }),
-    })
-  }))
-}
-
-function buildPrefixCounts(lines: readonly SDiffLine[]): {
-  readonly before: Int32Array
-  readonly after: Int32Array
-} {
-  const before = new Int32Array(lines.length + 1)
-  const after = new Int32Array(lines.length + 1)
-  for (let index = 0; index < lines.length; index += 1) {
-    before[index + 1] = before[index] + (lines[index].before === undefined ? 0 : 1)
-    after[index + 1] = after[index] + (lines[index].after === undefined ? 0 : 1)
-  }
-  return { before, after }
-}
-
-function buildHunksAndGaps(
-  lines: readonly SDiffLine[],
-  contextLines: number,
-): { readonly hunks: readonly SDiffHunk[]; readonly gaps: readonly SDiffGap[] } {
-  const changedIndices: number[] = []
-  lines.forEach((line, index) => {
-    if (line.kind !== 'unchanged') changedIndices.push(index)
-  })
-  if (changedIndices.length === 0) {
-    return { hunks: Object.freeze([]), gaps: Object.freeze([]) }
-  }
-
-  const windows: Array<{ start: number; end: number }> = []
-  for (const changedIndex of changedIndices) {
-    const start = Math.max(0, changedIndex - contextLines)
-    const end = Math.min(lines.length, changedIndex + contextLines + 1)
-    const previous = windows[windows.length - 1]
-    if (previous !== undefined && start <= previous.end) previous.end = Math.max(previous.end, end)
-    else windows.push({ start, end })
-  }
-
-  const prefix = buildPrefixCounts(lines)
-  const hunks = windows.map((window) => Object.freeze({
-    id: `hunk:${prefix.before[window.start] + 1}:${prefix.after[window.start] + 1}`,
-    lineStart: window.start,
-    lineEnd: window.end,
-    beforeStart: prefix.before[window.start] + 1,
-    beforeLineCount: prefix.before[window.end] - prefix.before[window.start],
-    afterStart: prefix.after[window.start] + 1,
-    afterLineCount: prefix.after[window.end] - prefix.after[window.start],
-  }))
-  const gaps: SDiffGap[] = []
-  let previousEnd = 0
-  for (const window of windows) {
-    if (window.start > previousEnd) {
-      const lineCount = window.start - previousEnd
-      gaps.push(Object.freeze({
-        id: `gap:${prefix.before[previousEnd] + 1}:${prefix.after[previousEnd] + 1}:${lineCount}`,
-        lineStart: previousEnd,
-        lineEnd: window.start,
-        beforeStart: prefix.before[previousEnd] + 1,
-        afterStart: prefix.after[previousEnd] + 1,
-        lineCount,
-      }))
-    }
-    previousEnd = window.end
-  }
-  if (previousEnd < lines.length) {
-    const lineCount = lines.length - previousEnd
-    gaps.push(Object.freeze({
-      id: `gap:${prefix.before[previousEnd] + 1}:${prefix.after[previousEnd] + 1}:${lineCount}`,
-      lineStart: previousEnd,
-      lineEnd: lines.length,
-      beforeStart: prefix.before[previousEnd] + 1,
-      afterStart: prefix.after[previousEnd] + 1,
-      lineCount,
-    }))
-  }
-  return { hunks: Object.freeze(hunks), gaps: Object.freeze(gaps) }
-}
-
-function snapshot(source: SDiffSource, lineCount: number): SDiffSourceSnapshot {
-  return Object.freeze({
-    lineCount,
-    ...(source.label === undefined ? {} : { label: source.label }),
-    ...(source.revision === undefined ? {} : { revision: source.revision }),
-    ...(source.language === undefined ? {} : { language: source.language }),
-  })
-}
-
-/** Pure deterministic engine used by both direct computation and the module worker. */
-export function computeDiffModel(
-  beforeSource: SDiffSource,
-  afterSource: SDiffSource,
-  options: Required<SDiffComputationOptions>,
-  isCancelled?: DiffCancellationProbe,
-): SDiffResult {
-  const checkpoint = new CancellationCheckpoint(isCancelled)
-  checkpoint.check(true)
-  const before = tokenize(beforeSource.text)
-  const after = tokenize(afterSource.text)
-  const operations: DiffOperation[] = []
-  diffRange(before, 0, before.length, after, 0, after.length, operations, checkpoint)
-  checkpoint.check(true)
-  const lines = buildLines(before, after, operations)
-  const { hunks, gaps } = buildHunksAndGaps(lines, options.contextLines)
-  const unchangedLineCount = lines.filter((line) => line.kind === 'unchanged').length
-  const removedLineCount = lines.filter((line) => line.kind === 'removed').length
-  const addedLineCount = lines.filter((line) => line.kind === 'added').length
-  return Object.freeze({
-    before: snapshot(beforeSource, before.length),
-    after: snapshot(afterSource, after.length),
-    lines,
-    hunks,
-    gaps,
-    summary: Object.freeze({
-      beforeLineCount: before.length,
-      afterLineCount: after.length,
-      unchangedLineCount,
-      removedLineCount,
-      addedLineCount,
-      changedLineCount: removedLineCount + addedLineCount,
-    }),
-  })
-}

package/src/internal/diffRuntime.ts

@@ -1,189 +0,0 @@
-import {
-  computeDiff,
-  validateDiffComputationOptions,
-  validateDiffSource,
-  type SDiffComputationOptions,
-  type SDiffResult,
-  type SDiffSource,
-} from '../components/shared/data-display/diff'
-import {
-  S_DIFF_WORKER_PROTOCOL_VERSION,
-  validateDiffWorkerResponse,
-  type SDiffWorkerRequest,
-} from '../workers/diffProtocol'
-
-export const S_DIFF_WORKER_TEXT_THRESHOLD = 32_768
-export const S_DIFF_WORKER_LINE_THRESHOLD = 1_200
-
-export interface SDiffWorkerLike {
-  postMessage(message: SDiffWorkerRequest): void
-  addEventListener(type: 'message', listener: (event: MessageEvent<unknown>) => void): void
-  addEventListener(type: 'error', listener: (event: ErrorEvent) => void): void
-  removeEventListener(type: 'message', listener: (event: MessageEvent<unknown>) => void): void
-  removeEventListener(type: 'error', listener: (event: ErrorEvent) => void): void
-  terminate(): void
-}
-
-export type SDiffWorkerFactory = () => SDiffWorkerLike
-
-export interface SDiffRuntime {
-  compute(
-    before: SDiffSource,
-    after: SDiffSource,
-    options?: SDiffComputationOptions,
-    signal?: AbortSignal,
-  ): Promise<SDiffResult>
-  dispose(): void
-}
-
-export class SDiffComputationCancelledError extends Error {
-  constructor(message = 'Diff computation was cancelled.') {
-    super(message)
-    this.name = 'SDiffComputationCancelledError'
-  }
-}
-
-interface ActiveRequest {
-  readonly cancel: (message?: string) => void
-}
-
-function countLines(text: string): number {
-  if (text.length === 0) return 0
-  let lineCount = text.endsWith('\n') ? 0 : 1
-  for (const character of text) {
-    if (character === '\n') lineCount += 1
-  }
-  return lineCount
-}
-
-export function shouldUseDiffWorker(before: SDiffSource, after: SDiffSource): boolean {
-  return before.text.length + after.text.length >= S_DIFF_WORKER_TEXT_THRESHOLD
-    || countLines(before.text) + countLines(after.text) >= S_DIFF_WORKER_LINE_THRESHOLD
-}
-
-function createDefaultWorker(): SDiffWorkerLike {
-  return new Worker(new URL('../workers/diff.worker.ts', import.meta.url), {
-    type: 'module',
-    name: 's-ui-kit-diff',
-  })
-}
-
-/** Creates an instance-owned worker runtime. Disposal cancels every retained computation resource. */
-export function createDiffRuntime(workerFactory: SDiffWorkerFactory = createDefaultWorker): SDiffRuntime {
-  let requestSequence = 0
-  let disposed = false
-  const activeRequests = new Map<string, ActiveRequest>()
-
-  const computeInWorker = (
-    before: SDiffSource,
-    after: SDiffSource,
-    options: Required<SDiffComputationOptions>,
-    signal: AbortSignal | undefined,
-  ): Promise<SDiffResult> => {
-    const requestId = `diff-request-${requestSequence += 1}`
-    const worker = workerFactory()
-    return new Promise<SDiffResult>((resolve, reject) => {
-      let settled = false
-      const cleanup = (): void => {
-        signal?.removeEventListener('abort', onAbort)
-        worker.removeEventListener('message', onMessage)
-        worker.removeEventListener('error', onError)
-        worker.terminate()
-        activeRequests.delete(requestId)
-      }
-      const failCancelled = (message?: string): void => {
-        if (settled) return
-        settled = true
-        try {
-          worker.postMessage({
-            version: S_DIFF_WORKER_PROTOCOL_VERSION,
-            type: 'cancel',
-            requestId,
-          })
-        } catch (cause) {
-          cleanup()
-          reject(cause)
-          return
-        }
-        cleanup()
-        reject(new SDiffComputationCancelledError(message))
-      }
-      const onAbort = (): void => failCancelled('Diff computation was aborted.')
-      const onError = (event: ErrorEvent): void => {
-        if (settled) return
-        settled = true
-        cleanup()
-        reject(new Error(`Diff worker failed: ${event.message}`))
-      }
-      const onMessage = (event: MessageEvent<unknown>): void => {
-        if (settled) return
-        let response
-        try {
-          response = validateDiffWorkerResponse(event.data)
-        } catch (cause) {
-          settled = true
-          cleanup()
-          reject(cause)
-          return
-        }
-        if (response.requestId !== requestId) {
-          settled = true
-          cleanup()
-          reject(new Error(
-            `Diff worker returned requestId ${JSON.stringify(response.requestId)} for active ${JSON.stringify(requestId)}.`,
-          ))
-          return
-        }
-        settled = true
-        cleanup()
-        if (response.type === 'result') resolve(response.result)
-        else if (response.type === 'cancelled') reject(new SDiffComputationCancelledError())
-        else {
-          const error = new Error(response.error.message)
-          error.name = response.error.name
-          reject(error)
-        }
-      }
-      activeRequests.set(requestId, { cancel: failCancelled })
-      signal?.addEventListener('abort', onAbort, { once: true })
-      worker.addEventListener('message', onMessage)
-      worker.addEventListener('error', onError)
-      try {
-        worker.postMessage({
-          version: S_DIFF_WORKER_PROTOCOL_VERSION,
-          type: 'compute',
-          requestId,
-          before,
-          after,
-          options,
-        })
-      } catch (cause) {
-        settled = true
-        cleanup()
-        reject(cause)
-      }
-    })
-  }
-
-  return Object.freeze({
-    async compute(
-      beforeValue: SDiffSource,
-      afterValue: SDiffSource,
-      optionsValue?: SDiffComputationOptions,
-      signal?: AbortSignal,
-    ): Promise<SDiffResult> {
-      if (disposed) throw new Error('Diff runtime is disposed.')
-      if (signal?.aborted === true) throw new SDiffComputationCancelledError('Diff computation was aborted.')
-      const before = validateDiffSource('SDiffRuntime', 'before', beforeValue)
-      const after = validateDiffSource('SDiffRuntime', 'after', afterValue)
-      const options = validateDiffComputationOptions('SDiffRuntime', optionsValue)
-      if (!shouldUseDiffWorker(before, after)) return computeDiff(before, after, options)
-      return computeInWorker(before, after, options, signal)
-    },
-    dispose(): void {
-      if (disposed) return
-      disposed = true
-      for (const request of [...activeRequests.values()]) request.cancel('Diff runtime was disposed.')
-    },
-  })
-}

package/src/internal/es2020.ts

@@ -1,50 +0,0 @@
-/** Проверяет собственное свойство без зависимости от ES2022 Object.hasOwn. / Checks an own property without the ES2022 Object.hasOwn API. */
-export function hasOwn(object: object, key: PropertyKey): boolean {
-  return Object.prototype.hasOwnProperty.call(object, key)
-}
-
-/** Возвращает последний элемент без зависимости от ES2022 Array.at. / Returns the last item without the ES2022 Array.at API. */
-export function lastItem<T>(items: readonly T[]): T | undefined {
-  return items.length > 0 ? items[items.length - 1] : undefined
-}
-
-/** Ошибка с ES2022-compatible cause, доступная в ES2020 runtime. / An ES2022-compatible error cause for ES2020 runtimes. */
-export type ErrorWithCause<T extends Error = Error> = T & { cause: unknown }
-
-/** Добавляет стандартный non-enumerable cause без требования ES2022 lib. / Adds the standard non-enumerable cause without requiring the ES2022 lib. */
-export function withErrorCause<T extends Error>(error: T, cause: unknown): ErrorWithCause<T> {
-  Object.defineProperty(error, 'cause', {
-    configurable: true,
-    value: cause,
-    writable: true,
-  })
-  return error as ErrorWithCause<T>
-}
-
-interface AggregateErrorLike extends Error {
-  readonly errors: readonly unknown[]
-}
-
-interface AggregateErrorConstructorLike {
-  new (errors: Iterable<unknown>, message?: string): AggregateErrorLike
-}
-
-class Es2020AggregateError extends Error implements AggregateErrorLike {
-  readonly errors: readonly unknown[]
-
-  constructor(errors: readonly unknown[], message: string) {
-    super(message)
-    this.name = 'AggregateError'
-    this.errors = [...errors]
-  }
-}
-
-/** Создаёт native AggregateError при наличии и точный ES2020 fallback иначе. / Creates a native AggregateError when available and an exact ES2020 fallback otherwise. */
-export function createAggregateError(errors: readonly unknown[], message: string): AggregateErrorLike {
-  const candidate: unknown = (globalThis as { AggregateError?: unknown }).AggregateError
-  if (typeof candidate === 'function') {
-    const AggregateErrorConstructor = candidate as AggregateErrorConstructorLike
-    return new AggregateErrorConstructor(errors, message)
-  }
-  return new Es2020AggregateError(errors, message)
-}