@vitos-pizza/vitos-pizza 0.1.0 → 0.3.0

package/packages/permission-system/node_modules/web-tree-sitter/lib/alloc.c

@@ -1,48 +0,0 @@
-#include "alloc.h"
-#include "tree_sitter/api.h"
-#include <stdlib.h>
-
-static void *ts_malloc_default(size_t size) {
-  void *result = malloc(size);
-  if (size > 0 && !result) {
-    fprintf(stderr, "tree-sitter failed to allocate %zu bytes", size);
-    abort();
-  }
-  return result;
-}
-
-static void *ts_calloc_default(size_t count, size_t size) {
-  void *result = calloc(count, size);
-  if (count > 0 && !result) {
-    fprintf(stderr, "tree-sitter failed to allocate %zu bytes", count * size);
-    abort();
-  }
-  return result;
-}
-
-static void *ts_realloc_default(void *buffer, size_t size) {
-  void *result = realloc(buffer, size);
-  if (size > 0 && !result) {
-    fprintf(stderr, "tree-sitter failed to reallocate %zu bytes", size);
-    abort();
-  }
-  return result;
-}
-
-// Allow clients to override allocation functions dynamically
-TS_PUBLIC void *(*ts_current_malloc)(size_t) = ts_malloc_default;
-TS_PUBLIC void *(*ts_current_calloc)(size_t, size_t) = ts_calloc_default;
-TS_PUBLIC void *(*ts_current_realloc)(void *, size_t) = ts_realloc_default;
-TS_PUBLIC void (*ts_current_free)(void *) = free;
-
-void ts_set_allocator(
-  void *(*new_malloc)(size_t size),
-  void *(*new_calloc)(size_t count, size_t size),
-  void *(*new_realloc)(void *ptr, size_t size),
-  void (*new_free)(void *ptr)
-) {
-  ts_current_malloc = new_malloc ? new_malloc : ts_malloc_default;
-  ts_current_calloc = new_calloc ? new_calloc : ts_calloc_default;
-  ts_current_realloc = new_realloc ? new_realloc : ts_realloc_default;
-  ts_current_free = new_free ? new_free : free;
-}

package/packages/permission-system/node_modules/web-tree-sitter/lib/alloc.h

@@ -1,41 +0,0 @@
-#ifndef TREE_SITTER_ALLOC_H_
-#define TREE_SITTER_ALLOC_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#if defined(TREE_SITTER_HIDDEN_SYMBOLS) || defined(_WIN32)
-#define TS_PUBLIC
-#else
-#define TS_PUBLIC __attribute__((visibility("default")))
-#endif
-
-TS_PUBLIC extern void *(*ts_current_malloc)(size_t size);
-TS_PUBLIC extern void *(*ts_current_calloc)(size_t count, size_t size);
-TS_PUBLIC extern void *(*ts_current_realloc)(void *ptr, size_t size);
-TS_PUBLIC extern void (*ts_current_free)(void *ptr);
-
-// Allow clients to override allocation functions
-#ifndef ts_malloc
-#define ts_malloc  ts_current_malloc
-#endif
-#ifndef ts_calloc
-#define ts_calloc  ts_current_calloc
-#endif
-#ifndef ts_realloc
-#define ts_realloc ts_current_realloc
-#endif
-#ifndef ts_free
-#define ts_free    ts_current_free
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // TREE_SITTER_ALLOC_H_

package/packages/permission-system/node_modules/web-tree-sitter/lib/array.h

@@ -1,291 +0,0 @@
-#ifndef TREE_SITTER_ARRAY_H_
-#define TREE_SITTER_ARRAY_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "./alloc.h"
-#include "./ts_assert.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4101)
-#elif defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-variable"
-#endif
-
-#define Array(T)       \
-  struct {             \
-    T *contents;       \
-    uint32_t size;     \
-    uint32_t capacity; \
-  }
-
-/// Initialize an array.
-#define array_init(self) \
-  ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL)
-
-/// Create an empty array.
-#define array_new() \
-  { NULL, 0, 0 }
-
-/// Get a pointer to the element at a given `index` in the array.
-#define array_get(self, _index) \
-  (ts_assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index])
-
-/// Get a pointer to the first element in the array.
-#define array_front(self) array_get(self, 0)
-
-/// Get a pointer to the last element in the array.
-#define array_back(self) array_get(self, (self)->size - 1)
-
-/// Clear the array, setting its size to zero. Note that this does not free any
-/// memory allocated for the array's contents.
-#define array_clear(self) ((self)->size = 0)
-
-/// Reserve `new_capacity` elements of space in the array. If `new_capacity` is
-/// less than the array's current capacity, this function has no effect.
-#define array_reserve(self, new_capacity) \
-  _array__reserve((Array *)(self), array_elem_size(self), new_capacity)
-
-/// Free any memory allocated for this array. Note that this does not free any
-/// memory allocated for the array's contents.
-#define array_delete(self) _array__delete((Array *)(self))
-
-/// Push a new `element` onto the end of the array.
-#define array_push(self, element)                            \
-  (_array__grow((Array *)(self), 1, array_elem_size(self)), \
-   (self)->contents[(self)->size++] = (element))
-
-/// Increase the array's size by `count` elements.
-/// New elements are zero-initialized.
-#define array_grow_by(self, count) \
-  do { \
-    if ((count) == 0) break; \
-    _array__grow((Array *)(self), count, array_elem_size(self)); \
-    memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \
-    (self)->size += (count); \
-  } while (0)
-
-/// Append all elements from one array to the end of another.
-#define array_push_all(self, other)                                       \
-  array_extend((self), (other)->size, (other)->contents)
-
-/// Append `count` elements to the end of the array, reading their values from the
-/// `contents` pointer.
-#define array_extend(self, count, contents)                    \
-  _array__splice(                                               \
-    (Array *)(self), array_elem_size(self), (self)->size, \
-    0, count,  contents                                        \
-  )
-
-/// Remove `old_count` elements from the array starting at the given `index`. At
-/// the same index, insert `new_count` new elements, reading their values from the
-/// `new_contents` pointer.
-#define array_splice(self, _index, old_count, new_count, new_contents)  \
-  _array__splice(                                                       \
-    (Array *)(self), array_elem_size(self), _index,                \
-    old_count, new_count, new_contents                                 \
-  )
-
-/// Insert one `element` into the array at the given `index`.
-#define array_insert(self, _index, element) \
-  _array__splice((Array *)(self), array_elem_size(self), _index, 0, 1, &(element))
-
-/// Remove one element from the array at the given `index`.
-#define array_erase(self, _index) \
-  _array__erase((Array *)(self), array_elem_size(self), _index)
-
-/// Pop the last element off the array, returning the element by value.
-#define array_pop(self) ((self)->contents[--(self)->size])
-
-/// Assign the contents of one array to another, reallocating if necessary.
-#define array_assign(self, other) \
-  _array__assign((Array *)(self), (const Array *)(other), array_elem_size(self))
-
-/// Swap one array with another
-#define array_swap(self, other) \
-  _array__swap((Array *)(self), (Array *)(other))
-
-/// Get the size of the array contents
-#define array_elem_size(self) (sizeof *(self)->contents)
-
-/// Search a sorted array for a given `needle` value, using the given `compare`
-/// callback to determine the order.
-///
-/// If an existing element is found to be equal to `needle`, then the `index`
-/// out-parameter is set to the existing value's index, and the `exists`
-/// out-parameter is set to true. Otherwise, `index` is set to an index where
-/// `needle` should be inserted in order to preserve the sorting, and `exists`
-/// is set to false.
-#define array_search_sorted_with(self, compare, needle, _index, _exists) \
-  _array__search_sorted(self, 0, compare, , needle, _index, _exists)
-
-/// Search a sorted array for a given `needle` value, using integer comparisons
-/// of a given struct field (specified with a leading dot) to determine the order.
-///
-/// See also `array_search_sorted_with`.
-#define array_search_sorted_by(self, field, needle, _index, _exists) \
-  _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists)
-
-/// Insert a given `value` into a sorted array, using the given `compare`
-/// callback to determine the order.
-#define array_insert_sorted_with(self, compare, value) \
-  do { \
-    unsigned _index, _exists; \
-    array_search_sorted_with(self, compare, &(value), &_index, &_exists); \
-    if (!_exists) array_insert(self, _index, value); \
-  } while (0)
-
-/// Insert a given `value` into a sorted array, using integer comparisons of
-/// a given struct field (specified with a leading dot) to determine the order.
-///
-/// See also `array_search_sorted_by`.
-#define array_insert_sorted_by(self, field, value) \
-  do { \
-    unsigned _index, _exists; \
-    array_search_sorted_by(self, field, (value) field, &_index, &_exists); \
-    if (!_exists) array_insert(self, _index, value); \
-  } while (0)
-
-// Private
-
-typedef Array(void) Array;
-
-/// This is not what you're looking for, see `array_delete`.
-static inline void _array__delete(Array *self) {
-  if (self->contents) {
-    ts_free(self->contents);
-    self->contents = NULL;
-    self->size = 0;
-    self->capacity = 0;
-  }
-}
-
-/// This is not what you're looking for, see `array_erase`.
-static inline void _array__erase(Array *self, size_t element_size,
-                                uint32_t index) {
-  ts_assert(index < self->size);
-  char *contents = (char *)self->contents;
-  memmove(contents + index * element_size, contents + (index + 1) * element_size,
-          (self->size - index - 1) * element_size);
-  self->size--;
-}
-
-/// This is not what you're looking for, see `array_reserve`.
-static inline void _array__reserve(Array *self, size_t element_size, uint32_t new_capacity) {
-  if (new_capacity > self->capacity) {
-    if (self->contents) {
-      self->contents = ts_realloc(self->contents, new_capacity * element_size);
-    } else {
-      self->contents = ts_malloc(new_capacity * element_size);
-    }
-    self->capacity = new_capacity;
-  }
-}
-
-/// This is not what you're looking for, see `array_assign`.
-static inline void _array__assign(Array *self, const Array *other, size_t element_size) {
-  _array__reserve(self, element_size, other->size);
-  self->size = other->size;
-  memcpy(self->contents, other->contents, self->size * element_size);
-}
-
-/// This is not what you're looking for, see `array_swap`.
-static inline void _array__swap(Array *self, Array *other) {
-  Array swap = *other;
-  *other = *self;
-  *self = swap;
-}
-
-/// This is not what you're looking for, see `array_push` or `array_grow_by`.
-static inline void _array__grow(Array *self, uint32_t count, size_t element_size) {
-  uint32_t new_size = self->size + count;
-  if (new_size > self->capacity) {
-    uint32_t new_capacity = self->capacity * 2;
-    if (new_capacity < 8) new_capacity = 8;
-    if (new_capacity < new_size) new_capacity = new_size;
-    _array__reserve(self, element_size, new_capacity);
-  }
-}
-
-/// This is not what you're looking for, see `array_splice`.
-static inline void _array__splice(Array *self, size_t element_size,
-                                 uint32_t index, uint32_t old_count,
-                                 uint32_t new_count, const void *elements) {
-  uint32_t new_size = self->size + new_count - old_count;
-  uint32_t old_end = index + old_count;
-  uint32_t new_end = index + new_count;
-  ts_assert(old_end <= self->size);
-
-  _array__reserve(self, element_size, new_size);
-
-  char *contents = (char *)self->contents;
-  if (self->size > old_end) {
-    memmove(
-      contents + new_end * element_size,
-      contents + old_end * element_size,
-      (self->size - old_end) * element_size
-    );
-  }
-  if (new_count > 0) {
-    if (elements) {
-      memcpy(
-        (contents + index * element_size),
-        elements,
-        new_count * element_size
-      );
-    } else {
-      memset(
-        (contents + index * element_size),
-        0,
-        new_count * element_size
-      );
-    }
-  }
-  self->size += new_count - old_count;
-}
-
-/// A binary search routine, based on Rust's `std::slice::binary_search_by`.
-/// This is not what you're looking for, see `array_search_sorted_with` or `array_search_sorted_by`.
-#define _array__search_sorted(self, start, compare, suffix, needle, _index, _exists) \
-  do { \
-    *(_index) = start; \
-    *(_exists) = false; \
-    uint32_t size = (self)->size - *(_index); \
-    if (size == 0) break; \
-    int comparison; \
-    while (size > 1) { \
-      uint32_t half_size = size / 2; \
-      uint32_t mid_index = *(_index) + half_size; \
-      comparison = compare(&((self)->contents[mid_index] suffix), (needle)); \
-      if (comparison <= 0) *(_index) = mid_index; \
-      size -= half_size; \
-    } \
-    comparison = compare(&((self)->contents[*(_index)] suffix), (needle)); \
-    if (comparison == 0) *(_exists) = true; \
-    else if (comparison < 0) *(_index) += 1; \
-  } while (0)
-
-/// Helper macro for the `_sorted_by` routines below. This takes the left (existing)
-/// parameter by reference in order to work with the generic sorting function above.
-#define _compare_int(a, b) ((int)*(a) - (int)(b))
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#elif defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // TREE_SITTER_ARRAY_H_

package/packages/permission-system/node_modules/web-tree-sitter/lib/atomic.h

@@ -1,68 +0,0 @@
-#ifndef TREE_SITTER_ATOMIC_H_
-#define TREE_SITTER_ATOMIC_H_
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#ifdef __TINYC__
-
-static inline size_t atomic_load(const volatile size_t *p) {
-  return *p;
-}
-
-static inline uint32_t atomic_inc(volatile uint32_t *p) {
-  *p += 1;
-  return *p;
-}
-
-static inline uint32_t atomic_dec(volatile uint32_t *p) {
-  *p-= 1;
-  return *p;
-}
-
-#elif defined(_WIN32)
-
-#include <windows.h>
-
-static inline size_t atomic_load(const volatile size_t *p) {
-  return *p;
-}
-
-static inline uint32_t atomic_inc(volatile uint32_t *p) {
-  return InterlockedIncrement((long volatile *)p);
-}
-
-static inline uint32_t atomic_dec(volatile uint32_t *p) {
-  return InterlockedDecrement((long volatile *)p);
-}
-
-#else
-
-static inline size_t atomic_load(const volatile size_t *p) {
-#ifdef __ATOMIC_RELAXED
-  return __atomic_load_n(p, __ATOMIC_RELAXED);
-#else
-  return __sync_fetch_and_add((volatile size_t *)p, 0);
-#endif
-}
-
-static inline uint32_t atomic_inc(volatile uint32_t *p) {
-  #ifdef __ATOMIC_RELAXED
-    return __atomic_add_fetch(p, 1U, __ATOMIC_SEQ_CST);
-  #else
-    return __sync_add_and_fetch(p, 1U);
-  #endif
-}
-
-static inline uint32_t atomic_dec(volatile uint32_t *p) {
-  #ifdef __ATOMIC_RELAXED
-    return __atomic_sub_fetch(p, 1U, __ATOMIC_SEQ_CST);
-  #else
-    return __sync_sub_and_fetch(p, 1U);
-  #endif
-}
-
-#endif
-
-#endif  // TREE_SITTER_ATOMIC_H_

package/packages/permission-system/node_modules/web-tree-sitter/lib/clock.h

@@ -1,146 +0,0 @@
-#ifndef TREE_SITTER_CLOCK_H_
-#define TREE_SITTER_CLOCK_H_
-
-#include <stdbool.h>
-#include <stdint.h>
-
-typedef uint64_t TSDuration;
-
-#ifdef _WIN32
-
-// Windows:
-// * Represent a time as a performance counter value.
-// * Represent a duration as a number of performance counter ticks.
-
-#include <windows.h>
-typedef uint64_t TSClock;
-
-static inline TSDuration duration_from_micros(uint64_t micros) {
-  LARGE_INTEGER frequency;
-  QueryPerformanceFrequency(&frequency);
-  return micros * (uint64_t)frequency.QuadPart / 1000000;
-}
-
-static inline uint64_t duration_to_micros(TSDuration self) {
-  LARGE_INTEGER frequency;
-  QueryPerformanceFrequency(&frequency);
-  return self * 1000000 / (uint64_t)frequency.QuadPart;
-}
-
-static inline TSClock clock_null(void) {
-  return 0;
-}
-
-static inline TSClock clock_now(void) {
-  LARGE_INTEGER result;
-  QueryPerformanceCounter(&result);
-  return (uint64_t)result.QuadPart;
-}
-
-static inline TSClock clock_after(TSClock base, TSDuration duration) {
-  return base + duration;
-}
-
-static inline bool clock_is_null(TSClock self) {
-  return !self;
-}
-
-static inline bool clock_is_gt(TSClock self, TSClock other) {
-  return self > other;
-}
-
-#elif defined(CLOCK_MONOTONIC)
-
-// POSIX with monotonic clock support (Linux, macOS)
-// * Represent a time as a monotonic (seconds, nanoseconds) pair.
-// * Represent a duration as a number of microseconds.
-//
-// On these platforms, parse timeouts will correspond accurately to
-// real time, regardless of what other processes are running.
-
-#include <time.h>
-typedef struct timespec TSClock;
-
-static inline TSDuration duration_from_micros(uint64_t micros) {
-  return micros;
-}
-
-static inline uint64_t duration_to_micros(TSDuration self) {
-  return self;
-}
-
-static inline TSClock clock_now(void) {
-  TSClock result;
-  clock_gettime(CLOCK_MONOTONIC, &result);
-  return result;
-}
-
-static inline TSClock clock_null(void) {
-  return (TSClock) {0, 0};
-}
-
-static inline TSClock clock_after(TSClock base, TSDuration duration) {
-  TSClock result = base;
-  result.tv_sec += duration / 1000000;
-  result.tv_nsec += (duration % 1000000) * 1000;
-  if (result.tv_nsec >= 1000000000) {
-    result.tv_nsec -= 1000000000;
-    ++(result.tv_sec);
-  }
-  return result;
-}
-
-static inline bool clock_is_null(TSClock self) {
-  return !self.tv_sec && !self.tv_nsec;
-}
-
-static inline bool clock_is_gt(TSClock self, TSClock other) {
-  if (self.tv_sec > other.tv_sec) return true;
-  if (self.tv_sec < other.tv_sec) return false;
-  return self.tv_nsec > other.tv_nsec;
-}
-
-#else
-
-// POSIX without monotonic clock support
-// * Represent a time as a process clock value.
-// * Represent a duration as a number of process clock ticks.
-//
-// On these platforms, parse timeouts may be affected by other processes,
-// which is not ideal, but is better than using a non-monotonic time API
-// like `gettimeofday`.
-
-#include <time.h>
-typedef uint64_t TSClock;
-
-static inline TSDuration duration_from_micros(uint64_t micros) {
-  return micros * (uint64_t)CLOCKS_PER_SEC / 1000000;
-}
-
-static inline uint64_t duration_to_micros(TSDuration self) {
-  return self * 1000000 / (uint64_t)CLOCKS_PER_SEC;
-}
-
-static inline TSClock clock_null(void) {
-  return 0;
-}
-
-static inline TSClock clock_now(void) {
-  return (uint64_t)clock();
-}
-
-static inline TSClock clock_after(TSClock base, TSDuration duration) {
-  return base + duration;
-}
-
-static inline bool clock_is_null(TSClock self) {
-  return !self;
-}
-
-static inline bool clock_is_gt(TSClock self, TSClock other) {
-  return self > other;
-}
-
-#endif
-
-#endif  // TREE_SITTER_CLOCK_H_

package/packages/permission-system/node_modules/web-tree-sitter/lib/error_costs.h

@@ -1,11 +0,0 @@
-#ifndef TREE_SITTER_ERROR_COSTS_H_
-#define TREE_SITTER_ERROR_COSTS_H_
-
-#define ERROR_STATE 0
-#define ERROR_COST_PER_RECOVERY 500
-#define ERROR_COST_PER_MISSING_TREE 110
-#define ERROR_COST_PER_SKIPPED_TREE 100
-#define ERROR_COST_PER_SKIPPED_LINE 30
-#define ERROR_COST_PER_SKIPPED_CHAR 1
-
-#endif