cline 1.0.0-nightly.19 → 1.0.0-nightly.20

package/node_modules/bare-events/lib/errors.js

@@ -0,0 +1,32 @@
+module.exports = class EventEmitterError extends Error {
+  constructor(msg, code, fn = EventEmitterError, opts) {
+    super(`${code}: ${msg}`, opts)
+    this.code = code
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, fn)
+    }
+  }
+
+  get name() {
+    return 'EventEmitterError'
+  }
+
+  static OPERATION_ABORTED(cause, msg = 'Operation aborted') {
+    return new EventEmitterError(
+      msg,
+      'OPERATION_ABORTED',
+      EventEmitterError.OPERATION_ABORTED,
+      { cause }
+    )
+  }
+
+  static UNHANDLED_ERROR(cause, msg = 'Unhandled error') {
+    return new EventEmitterError(
+      msg,
+      'UNHANDLED_ERROR',
+      EventEmitterError.UNHANDLED_ERROR,
+      { cause }
+    )
+  }
+}

package/node_modules/bare-events/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "bare-events",
+  "version": "2.8.0",
+  "description": "Event emitters for JavaScript",
+  "exports": {
+    "./package": "./package.json",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./global": {
+      "types": "./global.d.ts",
+      "default": "./global.js"
+    },
+    "./web": {
+      "types": "./web.d.ts",
+      "default": "./web.js"
+    },
+    "./errors": "./lib/errors.js"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "global.js",
+    "global.d.ts",
+    "web.js",
+    "web.d.ts",
+    "lib"
+  ],
+  "scripts": {
+    "test": "npm run lint && npm run test:bare && npm run test:node",
+    "test:bare": "bare test.js",
+    "test:node": "node test.js",
+    "lint": "prettier . --check"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/holepunchto/bare-events.git"
+  },
+  "author": "Holepunch",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/holepunchto/bare-events/issues"
+  },
+  "homepage": "https://github.com/holepunchto/bare-events#readme",
+  "devDependencies": {
+    "bare-abort-controller": "^1.0.0",
+    "brittle": "^3.3.2",
+    "prettier": "^3.4.2",
+    "prettier-config-standard": "^7.0.0",
+    "uncaughts": "^1.1.1"
+  },
+  "peerDependencies": {
+    "bare-abort-controller": "*"
+  },
+  "peerDependenciesMeta": {
+    "bare-abort-controller": {
+      "optional": true
+    }
+  }
+}

package/node_modules/bare-events/web.d.ts

@@ -0,0 +1,79 @@
+interface AbortSignal extends EventTarget {}
+
+export interface EventOptions {
+  bubbles?: boolean
+  cancelable?: boolean
+  composed?: boolean
+}
+
+export interface Event {
+  readonly type: string
+  readonly target: EventTarget | null
+  readonly currentTarget: EventTarget | null
+  readonly bubbles: boolean
+  readonly cancelable: boolean
+  readonly composed: boolean
+  readonly defaultPrevented: boolean
+  readonly isTrusted: boolean
+
+  preventDefault(): void
+  stopPropagation(): void
+  stopImmediatePropagation(): void
+}
+
+export class Event {
+  constructor(type: string, options?: EventOptions)
+}
+
+export interface CustomEventOptions<T = any> extends EventOptions {
+  detail?: T
+}
+
+export interface CustomEvent<T = any> extends Event {
+  readonly detail: T
+}
+
+export class CustomEvent<T = any> {
+  constructor(type: string, options?: CustomEventOptions<T>)
+}
+
+export interface AddEventListenerOptions {
+  capture?: boolean
+  passive?: boolean
+  once?: boolean
+  signal?: AbortSignal | null
+}
+
+export interface RemoveEventListenerOptions {
+  capture?: boolean
+}
+
+export interface EventTarget {
+  addEventListener(
+    type: string,
+    callback: EventListener,
+    options?: AddEventListenerOptions | boolean
+  ): void
+
+  removeEventListener(
+    type: string,
+    callback: EventListener,
+    options?: RemoveEventListenerOptions | boolean
+  ): void
+
+  dispatchEvent(event: Event): boolean
+}
+
+export class EventTarget {
+  constructor()
+}
+
+export type EventListener = EventCallback | EventHandler
+
+export interface EventCallback {
+  (event: Event): void
+}
+
+export interface EventHandler {
+  handleEvent(event: Event): void
+}

package/node_modules/bare-events/web.js

@@ -0,0 +1,347 @@
+// Event state
+const BUBBLES = 0x1
+const CANCELABLE = 0x2
+const COMPOSED = 0x4
+const CANCELED = 0x8
+const DISPATCH = 0x10
+const STOP = 0x20
+
+// EventTarget state
+const CAPTURE = 0x1
+const PASSIVE = 0x2
+const ONCE = 0x4
+
+// https://dom.spec.whatwg.org/#event
+class Event {
+  // https://dom.spec.whatwg.org/#dom-event-event
+  constructor(type, options = {}) {
+    const { bubbles = false, cancelable = false, composed = false } = options
+
+    this._type = type
+    this._target = null
+    this._state = 0
+
+    if (bubbles) this._state |= BUBBLES
+    if (cancelable) this._state |= CANCELABLE
+    if (composed) this._state |= COMPOSED
+  }
+
+  // https://dom.spec.whatwg.org/#dom-event-type
+  get type() {
+    return this._type
+  }
+
+  // https://dom.spec.whatwg.org/#dom-event-target
+  get target() {
+    return this._target
+  }
+
+  // https://dom.spec.whatwg.org/#dom-event-currenttarget
+  get currentTarget() {
+    return null
+  }
+
+  // https://dom.spec.whatwg.org/#dom-event-bubbles
+  get bubbles() {
+    return (this._state & BUBBLES) !== 0
+  }
+
+  // https://dom.spec.whatwg.org/#dom-event-cancelable
+  get cancelable() {
+    return (this._state & CANCELABLE) !== 0
+  }
+
+  // https://dom.spec.whatwg.org/#dom-event-composed
+  get composed() {
+    return (this._state & COMPOSED) !== 0
+  }
+
+  // https://dom.spec.whatwg.org/#dom-event-defaultprevented
+  get defaultPrevented() {
+    return (this._state & CANCELED) !== 0
+  }
+
+  // https://dom.spec.whatwg.org/#dom-event-istrusted
+  get isTrusted() {
+    return false
+  }
+
+  // https://dom.spec.whatwg.org/#dom-event-preventdefault
+  preventDefault() {
+    if (this._state & CANCELABLE) this._state |= CANCELED
+  }
+
+  // https://dom.spec.whatwg.org/#dom-event-stoppropagation
+  stopPropagation() {}
+
+  // https://dom.spec.whatwg.org/#dom-event-stopimmediatepropagation
+  stopImmediatePropagation() {
+    this._state |= STOP
+  }
+
+  toJSON() {
+    return {
+      type: this.type,
+      target: this.target,
+      bubbles: this.bubbles,
+      cancelable: this.cancelable,
+      composed: this.composed,
+      defaultPrevented: this.defaultPrevented,
+      isTrusted: this.isTrusted
+    }
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: Event },
+
+      type: this.type,
+      target: this.target,
+      bubbles: this.bubbles,
+      cancelable: this.cancelable,
+      composed: this.composed,
+      defaultPrevented: this.defaultPrevented,
+      isTrusted: this.isTrusted
+    }
+  }
+}
+
+exports.Event = Event
+
+// https://dom.spec.whatwg.org/#customevent
+exports.CustomEvent = class CustomEvent extends Event {
+  constructor(type, options = {}) {
+    super(type, options)
+
+    const { detail = null } = options
+
+    this._detail = detail
+  }
+
+  // https://dom.spec.whatwg.org/#dom-customevent-detail
+  get detail() {
+    return this._detail
+  }
+}
+
+// https://dom.spec.whatwg.org/#eventtarget
+exports.EventTarget = class EventTarget {
+  // https://dom.spec.whatwg.org/#dom-eventtarget-eventtarget
+  constructor() {
+    this._listeners = new Map()
+  }
+
+  // https://dom.spec.whatwg.org/#dom-eventtarget-addeventlistener
+  addEventListener(type, callback = null, options = {}) {
+    if (typeof options === 'boolean') options = { capture: options }
+
+    const {
+      capture = false,
+      passive = false,
+      once = false,
+      signal = null
+    } = options
+
+    if (signal !== null && signal.aborted) return
+    if (callback === null) return
+
+    const listener = new EventListener(
+      type,
+      callback,
+      capture,
+      passive,
+      once,
+      signal
+    )
+
+    const listeners = this._listeners.get(type)
+
+    if (listeners === undefined) this._listeners.set(type, listener)
+    else {
+      for (const existing of listeners) {
+        if (callback === existing.callback && capture === existing.capture) {
+          return // Duplicate listener
+        }
+      }
+
+      listener.link(listeners)
+
+      if (signal !== null) {
+        signal.addEventListener('abort', onabort)
+
+        function onabort() {
+          listener.unlink()
+        }
+      }
+    }
+  }
+
+  // https://dom.spec.whatwg.org/#dom-eventtarget-removeeventlistener
+  removeEventListener(type, callback = null, options = {}) {
+    if (typeof options === 'boolean') options = { capture: options }
+
+    const { capture = false } = options
+
+    const listeners = this._listeners.get(type)
+
+    if (listeners === undefined) return
+
+    for (const existing of listeners) {
+      if (callback === existing.callback && capture === existing.capture) {
+        const next = existing.unlink()
+
+        if (listeners === existing) this._listeners.set(type, next)
+
+        return
+      }
+    }
+  }
+
+  // https://dom.spec.whatwg.org/#dom-eventtarget-dispatchevent
+  dispatchEvent(event) {
+    event._target = this
+    event._state |= DISPATCH
+
+    const listeners = this._listeners.get(event.type)
+
+    try {
+      if (listeners === undefined) return true
+
+      for (const listener of listeners) {
+        // https://dom.spec.whatwg.org/#concept-event-listener-inner-invoke
+
+        if (listener.once) listener.unlink()
+
+        let callback = listener.callback
+        let context = this
+
+        if (typeof callback === 'object') {
+          context = callback
+          callback = callback.handleEvent
+        }
+
+        Reflect.apply(callback, context, [event])
+
+        if (event._state & STOP) break
+      }
+
+      return (event._state & CANCELED) === 0
+    } finally {
+      event._state &= ~DISPATCH
+      event._state &= ~STOP
+    }
+  }
+
+  toJSON() {
+    return {}
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: EventTarget }
+    }
+  }
+}
+
+// https://dom.spec.whatwg.org/#concept-event-listener
+class EventListener {
+  constructor(type, callback, capture, passive, once, signal) {
+    this._type = type
+    this._callback = callback
+    this._signal = signal
+    this._state = 0
+
+    if (capture) this._state |= CAPTURE
+    if (passive) this._state |= PASSIVE
+    if (once) this._state |= ONCE
+
+    this._previous = this
+    this._next = this
+  }
+
+  get type() {
+    return this._type
+  }
+
+  get callback() {
+    return this._callback
+  }
+
+  get capture() {
+    return (this._state & CAPTURE) !== 0
+  }
+
+  get passive() {
+    return (this._state & PASSIVE) !== 0
+  }
+
+  get once() {
+    return (this._state & ONCE) !== 0
+  }
+
+  get removed() {
+    return this._previous === this && this._next === this
+  }
+
+  link(listener) {
+    const next = this._next
+    const previous = listener._previous
+
+    this._next = listener
+    listener._previous = this
+
+    previous._next = next
+    next._previous = previous
+
+    return listener
+  }
+
+  unlink() {
+    if (this.removed) return this
+
+    const next = this._next
+    const previous = this._previous
+
+    this._next = this
+    this._previous = this
+
+    previous._next = next
+    next._previous = previous
+
+    return next
+  }
+
+  *[Symbol.iterator]() {
+    let current = this
+
+    while (true) {
+      const next = current._next
+      yield current
+      if (next === this) break
+      current = next
+    }
+  }
+
+  toJSON() {
+    return {
+      type: this.type,
+      capture: this.capture,
+      passive: this.passive,
+      once: this.once,
+      removed: this.removed
+    }
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: EventListener },
+
+      type: this.type,
+      callback: this.callback,
+      capture: this.capture,
+      passive: this.passive,
+      once: this.once,
+      removed: this.removed
+    }
+  }
+}

package/node_modules/bare-fs/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 4.0)
+
+find_package(cmake-bare REQUIRED PATHS node_modules/cmake-bare)
+
+project(bare_fs C)
+
+add_bare_module(bare_fs)
+
+target_sources(
+  ${bare_fs}
+  PRIVATE
+    binding.c
+)