bare-url 0.3.7 → 1.0.0

package/vendor/libutf/include/utf.h

@@ -0,0 +1,45 @@
+#ifndef UTF_H
+#define UTF_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+typedef uint_least8_t utf8_t;
+typedef uint_least16_t utf16_t;
+
+/**
+ * UTF-8
+ */
+
+bool
+utf8_validate (const utf8_t *data, size_t len);
+
+size_t
+utf8_length_from_utf16le (const utf16_t *data, size_t len);
+
+size_t
+utf8_convert_to_utf16le (const utf8_t *data, size_t len, utf16_t *result);
+
+/**
+ * UTF-16
+ */
+
+bool
+utf16le_validate (const utf16_t *data, size_t len);
+
+size_t
+utf16_length_from_utf8 (const utf8_t *data, size_t len);
+
+size_t
+utf16le_convert_to_utf8 (const utf16_t *data, size_t len, utf8_t *result);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UTF_H

package/vendor/libutf/src/endianness.c

@@ -0,0 +1,19 @@
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "../include/utf/endianness.h"
+
+extern utf_endianness_t
+utf_endianness (void);
+
+extern bool
+utf_is_le (void);
+
+extern bool
+utf_is_be (void);
+
+extern uint16_t
+utf_swap_uint16 (uint16_t n);
+
+extern uint32_t
+utf_swap_uint32 (uint32_t n);

package/vendor/libutf/src/utf16/utf8-convert.c

@@ -0,0 +1,77 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/endianness.h"
+
+/**
+ * Modified from https://github.com/simdutf/simdutf
+ *
+ * Copyright 2020 The simdutf authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+size_t
+utf16le_convert_to_utf8 (const utf16_t *data, size_t len, utf8_t *result) {
+  size_t pos = 0;
+  uint16_t word, diff;
+  utf8_t *start = result;
+
+  while (pos < len) {
+    if (pos + 4 <= len) {
+      uint64_t v;
+      memcpy(&v, data + pos, sizeof(uint64_t));
+      if (utf_is_be()) v = (v >> 8) | (v << (64 - 8));
+      if ((v & 0xff80ff80ff80ff80) == 0) {
+        size_t final_pos = pos + 4;
+        while (pos < final_pos) {
+          *result++ = utf_is_be() ? utf_swap_uint16(data[pos]) : data[pos];
+          pos++;
+        }
+        continue;
+      }
+    }
+
+    word = utf_is_be() ? utf_swap_uint16(data[pos]) : data[pos];
+    if ((word & 0xff80) == 0) {
+      *result++ = word;
+      pos++;
+    } else if ((word & 0xf800) == 0) {
+      *result++ = (word >> 6) | 0b11000000;
+      *result++ = (word & 0b111111) | 0b10000000;
+      pos++;
+    } else if ((word & 0xf800) != 0xd800) {
+      *result++ = (word >> 12) | 0b11100000;
+      *result++ = ((word >> 6) & 0b111111) | 0b10000000;
+      *result++ = (word & 0b111111) | 0b10000000;
+      pos++;
+    } else {
+      diff = word - 0xd800;
+      if (pos + 1 >= len) {
+        return 0;
+      }
+      word = utf_is_be() ? utf_swap_uint16(data[pos + 1]) : data[pos + 1];
+      uint32_t value = (diff << 10) + (word - 0xdc00) + 0x10000;
+      *result++ = (value >> 18) | 0b11110000;
+      *result++ = ((value >> 12) & 0b111111) | 0b10000000;
+      *result++ = ((value >> 6) & 0b111111) | 0b10000000;
+      *result++ = (value & 0b111111) | 0b10000000;
+      pos += 2;
+    }
+  }
+
+  return result - start;
+}

package/vendor/libutf/src/utf16/utf8-length.c

@@ -0,0 +1,45 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/endianness.h"
+
+/**
+ * Modified from https://github.com/simdutf/simdutf
+ *
+ * Copyright 2020 The simdutf authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+size_t
+utf8_length_from_utf16le (const utf16_t *data, size_t len) {
+  size_t counter = 0;
+  uint16_t word;
+
+  for (size_t i = 0; i < len; i++) {
+    word = utf_is_be() ? utf_swap_uint16(data[i]) : data[i];
+    if (word <= 0x7f) {
+      counter++;
+    } else if (word <= 0x7ff) {
+      counter += 2;
+    } else if ((word <= 0xd7ff) || (word >= 0xe000)) {
+      counter += 3;
+    } else {
+      counter += 2;
+    }
+  }
+
+  return counter;
+}

package/vendor/libutf/src/utf16/validate.c

@@ -0,0 +1,53 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/endianness.h"
+
+/**
+ * Modified from https://github.com/simdutf/simdutf
+ *
+ * Copyright 2020 The simdutf authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+bool
+utf16le_validate (const utf16_t *data, size_t len) {
+  uint64_t pos = 0;
+  uint16_t word, diff;
+
+  while (pos < len) {
+    word = utf_is_be() ? utf_swap_uint16(data[pos]) : data[pos];
+    if ((word & 0xf800) == 0xd800) {
+      if (pos + 1 >= len) {
+        return false;
+      }
+      diff = word - 0xd800;
+      if (diff > 0x3ff) {
+        return false;
+      }
+      word = utf_is_be() ? utf_swap_uint16(data[pos + 1]) : data[pos + 1];
+      diff = word - 0xdc00;
+      if (diff > 0x3ff) {
+        return false;
+      }
+      pos += 2;
+    } else {
+      pos++;
+    }
+  }
+
+  return true;
+}

package/vendor/libutf/src/utf8/string.c

@@ -0,0 +1,148 @@
+#include <stddef.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+extern void
+utf8_string_init (utf8_string_t *string);
+
+extern utf8_string_view_t
+utf8_string_view_init (const utf8_t *data, size_t len);
+
+extern void
+utf8_string_destroy (utf8_string_t *string);
+
+extern int
+utf8_string_reserve (utf8_string_t *string, size_t len);
+
+extern int
+utf8_string_shrink_to_fit (utf8_string_t *string);
+
+extern utf8_string_view_t
+utf8_string_view (const utf8_string_t *string);
+
+extern void
+utf8_string_clear (utf8_string_t *string);
+
+extern bool
+utf8_string_empty (utf8_string_t *string);
+
+extern bool
+utf8_string_view_empty (const utf8_string_view_t view);
+
+extern int
+utf8_string_copy (const utf8_string_t *string, utf8_string_t *result);
+
+extern int
+utf8_string_view_copy (const utf8_string_view_t view, utf8_string_t *result);
+
+extern int
+utf8_string_append (utf8_string_t *string, const utf8_string_t *other);
+
+extern int
+utf8_string_append_view (utf8_string_t *string, const utf8_string_view_t view);
+
+extern int
+utf8_string_append_character (utf8_string_t *string, utf8_t c);
+
+extern int
+utf8_string_append_literal (utf8_string_t *string, const utf8_t *literal, size_t n);
+
+extern int
+utf8_string_prepend (utf8_string_t *string, const utf8_string_t *other);
+
+extern int
+utf8_string_prepend_view (utf8_string_t *string, const utf8_string_view_t view);
+
+extern int
+utf8_string_prepend_character (utf8_string_t *string, utf8_t c);
+
+extern int
+utf8_string_prepend_literal (utf8_string_t *string, const utf8_t *literal, size_t n);
+
+extern int
+utf8_string_insert (utf8_string_t *string, size_t pos, const utf8_string_t *other);
+
+extern int
+utf8_string_insert_view (utf8_string_t *string, size_t pos, const utf8_string_view_t other);
+
+extern int
+utf8_string_insert_character (utf8_string_t *string, size_t pos, utf8_t c);
+
+extern int
+utf8_string_insert_literal (utf8_string_t *string, size_t pos, const utf8_t *literal, size_t n);
+
+extern int
+utf8_string_replace (utf8_string_t *string, size_t pos, size_t len, const utf8_string_t *replacement);
+
+extern int
+utf8_string_replace_view (utf8_string_t *string, size_t pos, size_t len, const utf8_string_view_t replacement);
+
+extern int
+utf8_string_replace_character (utf8_string_t *string, size_t pos, size_t len, utf8_t c);
+
+extern int
+utf8_string_replace_literal (utf8_string_t *string, size_t pos, size_t len, const utf8_t *literal, size_t n);
+
+extern int
+utf8_string_erase (utf8_string_t *string, size_t pos, size_t len);
+
+extern int
+utf8_string_concat (const utf8_string_t *string, const utf8_string_t *other, utf8_string_t *result);
+
+extern int
+utf8_string_view_concat (const utf8_string_view_t view, const utf8_string_t *other, utf8_string_t *result);
+
+extern int
+utf8_string_concat_view (const utf8_string_t *string, const utf8_string_view_t other, utf8_string_t *result);
+
+extern int
+utf8_string_view_concat_view (const utf8_string_view_t view, const utf8_string_view_t other, utf8_string_t *result);
+
+extern int
+utf8_string_concat_character (const utf8_string_t *string, utf8_t c, utf8_string_t *result);
+
+extern int
+utf8_string_view_concat_character (const utf8_string_view_t view, utf8_t c, utf8_string_t *result);
+
+extern int
+utf8_string_concat_literal (const utf8_string_t *string, const utf8_t *literal, size_t n, utf8_string_t *result);
+
+extern int
+utf8_string_view_concat_literal (const utf8_string_view_t view, const utf8_t *literal, size_t n, utf8_string_t *result);
+
+extern int
+utf8_string_compare (const utf8_string_t *string, const utf8_string_t *other);
+
+extern int
+utf8_string_view_compare (const utf8_string_view_t view, const utf8_string_view_t other);
+
+extern int
+utf8_string_compare_literal (const utf8_string_t *string, const utf8_t *literal, size_t n);
+
+extern int
+utf8_string_view_compare_literal (const utf8_string_view_t view, const utf8_t *literal, size_t n);
+
+extern utf8_string_view_t
+utf8_string_substring (const utf8_string_t *string, size_t start, size_t end);
+
+extern utf8_string_view_t
+utf8_string_view_substring (const utf8_string_view_t view, size_t start, size_t end);
+
+extern int
+utf8_string_substring_copy (const utf8_string_t *string, size_t start, size_t end, utf8_string_t *result);
+
+extern int
+utf8_string_view_substring_copy (const utf8_string_view_t view, size_t start, size_t end, utf8_string_t *result);
+
+extern size_t
+utf8_string_index_of_character (const utf8_string_t *string, size_t pos, utf8_t c);
+
+extern size_t
+utf8_string_view_index_of_character (const utf8_string_view_t view, size_t pos, utf8_t c);
+
+extern size_t
+utf8_string_last_index_of_character (const utf8_string_t *string, size_t pos, utf8_t c);
+
+extern size_t
+utf8_string_view_last_index_of_character (const utf8_string_view_t view, size_t pos, utf8_t c);

package/vendor/libutf/src/utf8/utf16-convert.c

@@ -0,0 +1,90 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/endianness.h"
+
+/**
+ * Modified from https://github.com/simdutf/simdutf
+ *
+ * Copyright 2020 The simdutf authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+size_t
+utf8_convert_to_utf16le (const utf8_t *data, size_t len, utf16_t *result) {
+  size_t pos = 0;
+  utf16_t *start = result;
+
+  while (pos < len) {
+    if (pos + 8 <= len) {
+      uint64_t v;
+      memcpy(&v, data + pos, sizeof(uint64_t));
+      if ((v & 0x8080808080808080) == 0) {
+        size_t final_pos = pos + 8;
+        while (pos < final_pos) {
+          *result++ = utf_is_be() ? utf_swap_uint16(data[pos]) : data[pos];
+          pos++;
+        }
+        continue;
+      }
+    }
+    uint8_t leading_byte = data[pos];
+    if (leading_byte < 0b10000000) {
+      *result++ = utf_is_be() ? utf_swap_uint16(leading_byte) : leading_byte;
+      pos++;
+    } else if ((leading_byte & 0b11100000) == 0b11000000) {
+      if (pos + 1 >= len) {
+        break;
+      }
+      uint16_t code_point = ((leading_byte & 0b00011111) << 6) | (data[pos + 1] & 0b00111111);
+      if (utf_is_be()) {
+        code_point = utf_swap_uint16(code_point);
+      }
+      *result++ = code_point;
+      pos += 2;
+    } else if ((leading_byte & 0b11110000) == 0b11100000) {
+      if (pos + 2 >= len) {
+        break;
+      }
+      uint16_t code_point = ((leading_byte & 0b00001111) << 12) | ((data[pos + 1] & 0b00111111) << 6) | (data[pos + 2] & 0b00111111);
+      if (utf_is_be()) {
+        code_point = utf_swap_uint16(code_point);
+      }
+      *result++ = code_point;
+      pos += 3;
+    } else if ((leading_byte & 0b11111000) == 0b11110000) {
+      if (pos + 3 >= len) {
+        break;
+      }
+      uint32_t code_point = ((leading_byte & 0b00000111) << 18) | ((data[pos + 1] & 0b00111111) << 12) | ((data[pos + 2] & 0b00111111) << 6) | (data[pos + 3] & 0b00111111);
+      code_point -= 0x10000;
+      uint16_t high_surrogate = 0xd800 + (code_point >> 10);
+      uint16_t low_surrogate = 0xdc00 + (code_point & 0x3ff);
+      if (utf_is_be()) {
+        high_surrogate = utf_swap_uint16(high_surrogate);
+        low_surrogate = utf_swap_uint16(low_surrogate);
+      }
+      *result++ = high_surrogate;
+      *result++ = low_surrogate;
+      pos += 4;
+    } else {
+      return 0;
+    }
+  }
+
+  return result - start;
+}

package/vendor/libutf/src/utf8/utf16-length.c

@@ -0,0 +1,39 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "../../include/utf.h"
+
+/**
+ * Modified from https://github.com/simdutf/simdutf
+ *
+ * Copyright 2020 The simdutf authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+size_t
+utf16_length_from_utf8 (const utf8_t *data, size_t len) {
+  size_t counter = 0;
+
+  for (size_t i = 0; i < len; i++) {
+    if ((int8_t) data[i] > -65) {
+      counter++;
+    }
+    if (data[i] >= 240) {
+      counter++;
+    }
+  }
+
+  return counter;
+}

package/vendor/libutf/src/utf8/validate.c

@@ -0,0 +1,107 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+
+/**
+ * Modified from https://github.com/simdutf/simdutf
+ *
+ * Copyright 2020 The simdutf authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+bool
+utf8_validate (const utf8_t *data, size_t len) {
+  uint64_t pos = 0;
+  uint32_t code_point;
+  uint8_t word;
+
+  while (pos < len) {
+    uint64_t next_pos = pos + 16;
+    if (next_pos <= len) {
+      uint64_t v1;
+      memcpy(&v1, data + pos, sizeof(uint64_t));
+      uint64_t v2;
+      memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+      uint64_t v = v1 | v2;
+      if ((v & 0x8080808080808080) == 0) {
+        pos = next_pos;
+        continue;
+      }
+    }
+
+    word = data[pos];
+    while (word < 0b10000000) {
+      if (++pos == len) return true;
+      word = data[pos];
+    }
+
+    if ((word & 0b11100000) == 0b11000000) {
+      next_pos = pos + 2;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      code_point = (word & 0b00011111) << 6 | (data[pos + 1] & 0b00111111);
+      if ((code_point < 0x80) || (0x7ff < code_point)) {
+        return false;
+      }
+    } else if ((word & 0b11110000) == 0b11100000) {
+      next_pos = pos + 3;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      code_point = (word & 0b00001111) << 12 |
+                   (data[pos + 1] & 0b00111111) << 6 |
+                   (data[pos + 2] & 0b00111111);
+      if ((code_point < 0x800) || (0xffff < code_point) || (0xd7ff < code_point && code_point < 0xe000)) {
+        return false;
+      }
+    } else if ((word & 0b11111000) == 0b11110000) {
+      next_pos = pos + 4;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 3] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      code_point = (word & 0b00000111) << 18 | (data[pos + 1] & 0b00111111) << 12 |
+                   (data[pos + 2] & 0b00111111) << 6 | (data[pos + 3] & 0b00111111);
+      if (code_point <= 0xffff || 0x10ffff < code_point) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+    pos = next_pos;
+  }
+
+  return true;
+}

package/lib/constants.js

@@ -1,25 +0,0 @@
-module.exports = {
-  // Parser states
-  // https://url.spec.whatwg.org/#url-parsing
-  STATE_SCHEME_START: 1,
-  STATE_SCHEME: 2,
-  STATE_NO_SCHEME: 3,
-  STATE_SPECIAL_RELATIVE_OR_AUTHORITY: 4,
-  STATE_PATH_OR_AUTHORITY: 5,
-  STATE_RELATIVE: 6,
-  STATE_RELATIVE_SLASH: 7,
-  STATE_SPECIAL_AUTHORITY_SLASHES: 8,
-  STATE_SPECIAL_AUTHORITY_IGNORE_SLASHES: 9,
-  STATE_AUTHORITY: 10,
-  STATE_HOST: 11,
-  STATE_HOSTNAME: 12,
-  STATE_PORT: 13,
-  STATE_FILE: 14,
-  STATE_FILE_SLASH: 15,
-  STATE_FILE_HOST: 16,
-  STATE_PATH_START: 17,
-  STATE_PATH: 18,
-  STATE_OPAQUE_PATH: 19,
-  STATE_QUERY: 20,
-  STATE_FRAGMENT: 21
-}

package/lib/infra.js

@@ -1,39 +0,0 @@
-// https://infra.spec.whatwg.org/#ascii-digit
-exports.isASCIIDigit = function isASCIIDigit (c) {
-  return c >= 0x30 && c <= 0x39
-}
-
-// https://infra.spec.whatwg.org/#ascii-upper-hex-digit
-exports.isASCIIUpperHexDigit = function isASCIIUpperHexDigit (c) {
-  return exports.isASCIIDigit(c) || (c >= 0x41 && c <= 0x46)
-}
-
-// https://infra.spec.whatwg.org/#ascii-lower-hex-digit
-exports.isASCIILowerHexDigit = function isASCIILowerHexDigit (c) {
-  return exports.isASCIIDigit(c) || (c >= 0x61 && c <= 0x66)
-}
-
-// https://infra.spec.whatwg.org/#ascii-hex-digit
-exports.isASCIIHexDigit = function isASCIIHexDigit (c) {
-  return exports.isASCIIDigit(c) || (c >= 0x41 && c <= 0x46) || (c >= 0x61 && c <= 0x66)
-}
-
-// https://infra.spec.whatwg.org/#ascii-upper-alpha
-exports.isASCIIUpperAlpha = function isASCIIUpperAlpha (c) {
-  return c >= 0x41 && c <= 0x5a
-}
-
-// https://infra.spec.whatwg.org/#ascii-lower-alpha
-exports.isASCIILowerAlpha = function isASCIILowerAlpha (c) {
-  return c >= 0x61 && c <= 0x7a
-}
-
-// https://infra.spec.whatwg.org/#ascii-alpha
-exports.isASCIIAlpha = function isASCIIAlpha (c) {
-  return exports.isASCIIUpperAlpha(c) || exports.isASCIILowerAlpha(c)
-}
-
-// https://infra.spec.whatwg.org/#ascii-alphanumeric
-exports.isASCIIAlphanumeric = function isASCIIAlphanumeric (c) {
-  return exports.isASCIIDigit(c) || exports.isASCIIAlpha(c)
-}