KaQuMiQ

import OSLog
import class Foundation.Bundle
import class Foundation.ProcessInfo
import struct Foundation.TimeZone

/// Diagnostics allows debugging and gathering usage data.
public enum Diagnostics {

	/// Info including application name and version.
	public static let info: String = {

KaQuMiQ

extension Optional
where Wrapped == Task<Void, Never> {

	public mutating func clearIfCurrent() {
		switch self {
		case .some(let task) where task.isCurrent:
			self = .none

		case _:
			break // noop

KaQuMiQ

import Foundation

extension JSONEncoder {

  public func encode(
    any anyEncodable: any Encodable
  ) throws -> Data {
    try self.encode(
      JSONEncodingWrapper(encodable: anyEncodable)
    )

KaQuMiQ

import libkern

@usableFromInline
internal final class AsyncSpinLock {

  @TaskLocal private static var taskContext: Array<AsyncSpinLock> = .init()

  @usableFromInline
  internal let atomicFlagPointer: UnsafeMutablePointer<atomic_flag>

KaQuMiQ

import Combine

extension Publisher {

  public func asAsyncThrowingSequence() -> StreamedAsyncThrowingSequence<Output> {
    StreamedAsyncThrowingSequence(self)
  }
}

extension Publisher where Failure == Never {

KaQuMiQ

import struct Foundation.UUID
import os
import libkern

public enum MemoryLeaks {

  public static func listActiveMarkers() -> Array<Marker> {
    let markersRegistryCopy: Dictionary<AnyHashable, WeakMarker> = markersRegistryLock
      .withLock { Self.markersRegistry }
    return markersRegistryCopy.values.compactMap(\.marker)

KaQuMiQ

public struct Tagged<RawValue, Type>: RawRepresentable {
  
  public var rawValue: RawValue
  
  public init(
    rawValue: RawValue
  ) {
    self.rawValue = rawValue
  }
}

KaQuMiQ

import Foundation
import SQLite3

private final class SQLiteHandle {
  
  fileprivate var handle: OpaquePointer?
  
  fileprivate init(handle: OpaquePointer?) {
    self.handle = handle
  }

KaQuMiQ

import Atomics

public final class Future<Value> {
  
  private let fulfillmentStatus: ManagedAtomic<Bool>
  private let valueStatus: ManagedAtomic<Bool>
  private let handlingStatus: ManagedAtomic<Bool>
  private let handlerStatus: ManagedAtomic<Bool>
  private let completionStatus: ManagedAtomic<Bool>
  

KaQuMiQ

import struct Foundation.TimeInterval
import struct Foundation.Date
import class Atomics.ManagedAtomic

/// Cancelation token that can be used to cancel associated tasks.
public struct Cancelation {
  
  private var status: () -> Bool
  private var cancelation: () -> Void
}