bare-url 1.1.1 → 1.2.0

package/binding.c

@@ -14,13 +14,17 @@ static js_value_t *
 bare_url_parse (js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 5;
-  js_value_t *argv[5];
+  size_t argc = 4;
+  js_value_t *argv[4];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 5);
+  assert(argc == 4);
+
+  bool should_throw;
+  err = js_get_value_bool(env, argv[3], &should_throw);
+  assert(err == 0);
 
   bool has_base;
   err = js_is_string(env, argv[1], &has_base);
@@ -45,7 +49,7 @@ bare_url_parse (js_env_t *env, js_callback_info_t *info) {
     if (err < 0) {
       url_destroy(&base);
 
-      js_throw_error(env, NULL, "Invalid base URL");
+      if (should_throw) js_throw_error(env, NULL, "Invalid base URL");
 
       return NULL;
     }
@@ -72,7 +76,7 @@ bare_url_parse (js_env_t *env, js_callback_info_t *info) {
     url_destroy(&base);
     url_destroy(&url);
 
-    js_throw_error(env, NULL, "Invalid URL");
+    if (should_throw) js_throw_error(env, NULL, "Invalid URL");
 
     return NULL;
   }
@@ -81,17 +85,8 @@ bare_url_parse (js_env_t *env, js_callback_info_t *info) {
   err = js_create_string_utf8(env, url.href.data, url.href.len, &href);
   assert(err == 0);
 
-  bool tag;
-  err = js_get_value_bool(env, argv[2], &tag);
-  assert(err == 0);
-
-  if (tag) {
-    err = js_add_type_tag(env, argv[3], &bare_url__tag);
-    assert(err == 0);
-  }
-
   uint32_t *components;
-  err = js_get_typedarray_info(env, argv[4], NULL, (void **) &components, NULL, NULL, NULL);
+  err = js_get_typedarray_info(env, argv[2], NULL, (void **) &components, NULL, NULL, NULL);
   assert(err == 0);
 
   memcpy(components, &url.components, sizeof(url.components));
@@ -171,7 +166,25 @@ bare_url_can_parse (js_env_t *env, js_callback_info_t *info) {
 }
 
 static js_value_t *
-bare_url_is_url (js_env_t *env, js_callback_info_t *info) {
+bare_url_tag (js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 1;
+  js_value_t *argv[1];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  err = js_add_type_tag(env, argv[0], &bare_url__tag);
+  assert(err == 0);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_url_is_tagged (js_env_t *env, js_callback_info_t *info) {
   int err;
 
   size_t argc = 1;
@@ -208,7 +221,8 @@ bare_url_exports (js_env_t *env, js_value_t *exports) {
 
   V("parse", bare_url_parse)
   V("canParse", bare_url_can_parse)
-  V("isURL", bare_url_is_url)
+  V("tag", bare_url_tag)
+  V("isTagged", bare_url_is_tagged)
 #undef V
 
   return exports;

package/index.js

@@ -7,14 +7,20 @@ const errors = require('./lib/errors')
 const isWindows = Bare.platform === 'win32'
 
 const URL = module.exports = exports = class URL {
-  constructor (href, base) {
-    if (typeof href !== 'string') throw errors.INVALID_URL()
+  static {
+    binding.tag(this)
+  }
+
+  constructor (input, base, opts = {}) {
+    if (arguments.length === 0) throw errors.INVALID_URL()
+
+    input = `${input}`
 
-    if (base && typeof base !== 'string') base = base.href
+    if (base !== undefined) base = `${base}`
 
     this._components = new Uint32Array(8)
 
-    this._parse(href, base, true /* Tag */)
+    this._parse(input, base, opts.throw !== false)
   }
 
   // https://url.spec.whatwg.org/#dom-url-href
@@ -204,9 +210,9 @@ const URL = module.exports = exports = class URL {
     return this._slice(0, start) + replacement + this._slice(end)
   }
 
-  _parse (href, base, tag = false) {
+  _parse (href, base, shouldThrow) {
     try {
-      this._href = binding.parse(String(href), base ? String(base) : null, tag, this, this._components)
+      this._href = binding.parse(String(href), base ? String(base) : null, this._components, shouldThrow)
     } catch (err) {
       safetyCatch(err)
 
@@ -216,7 +222,7 @@ const URL = module.exports = exports = class URL {
 
   _update (href) {
     try {
-      this._parse(href, null, false /* Tag */)
+      this._parse(href, null, true)
     } catch (err) {
       safetyCatch(err)
     }
@@ -236,11 +242,26 @@ function cannotHaveCredentialsOrPort (url) {
 exports.URL = exports // For Node.js compatibility
 
 exports.isURL = function isURL (value) {
-  return typeof value === 'object' && value !== null && binding.isURL(value)
+  if (typeof value !== 'object' || value === null) return false
+
+  let constructor = value.constructor
+
+  while (typeof constructor === 'function') {
+    if (binding.isTagged(constructor)) return true
+
+    constructor = Reflect.getPrototypeOf(constructor)
+  }
+
+  return false
+}
+
+exports.parse = function parse (input, base) {
+  const url = new URL(input, base, { throw: false })
+  return url.href ? url : null
 }
 
-exports.canParse = function canParse (href, base) {
-  return binding.canParse(String(href), base ? String(base) : null)
+exports.canParse = function canParse (input, base) {
+  return binding.canParse(String(input), base ? String(base) : null)
 }
 
 exports.fileURLToPath = function fileURLToPath (url) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-url",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "WHATWG URL implementation for JavaScript",
   "main": "index.js",
   "files": [

package/vendor/liburl/src/parse.h

@@ -882,8 +882,10 @@ url__parse (url_t *url, const utf8_string_view_t input, const url_t *base) {
         utf8_string_view_t host = url_get_host(base);
 
         if (!utf8_string_view_empty(host)) {
-          err = utf8_string_append_literal(&url->href, (utf8_t *) "//", 2);
-          if (err < 0) goto err;
+          if (url->type == url_type_opaque) {
+            err = utf8_string_append_literal(&url->href, (utf8_t *) "//", 2);
+            if (err < 0) goto err;
+          }
 
           utf8_string_view_t username = url_get_username(base);
 

package/vendor/libutf/CMakeLists.txt

@@ -15,17 +15,33 @@ target_sources(
   utf
   INTERFACE
     include/utf.h
-    include/utf/endianness.h
     include/utf/string.h
   PRIVATE
     src/endianness.c
-    src/utf8/utf16-convert.c
-    src/utf8/utf16-length.c
-    src/utf8/validate.c
+    src/endianness.h
+    src/ascii/validate.c
+    src/utf8/convert-to-latin1.c
+    src/utf8/convert-to-utf16.c
+    src/utf8/convert-to-utf32.c
+    src/utf8/length-from-latin1.c
+    src/utf8/length-from-utf16.c
+    src/utf8/length-from-utf32.c
     src/utf8/string.c
-    src/utf16/utf8-convert.c
-    src/utf16/utf8-length.c
+    src/utf8/validate.c
+    src/utf16/convert-to-latin1.c
+    src/utf16/convert-to-utf8.c
+    src/utf16/convert-to-utf32.c
+    src/utf16/length-from-latin1.c
+    src/utf16/length-from-utf8.c
+    src/utf16/length-from-utf32.c
     src/utf16/validate.c
+    src/utf32/convert-to-latin1.c
+    src/utf32/convert-to-utf8.c
+    src/utf32/convert-to-utf16.c
+    src/utf32/length-from-latin1.c
+    src/utf32/length-from-utf8.c
+    src/utf32/length-from-utf16.c
+    src/utf32/validate.c
 )
 
 target_include_directories(
@@ -72,5 +88,6 @@ install(DIRECTORY include/utf DESTINATION include)
 
 if(PROJECT_IS_TOP_LEVEL)
   enable_testing()
+
   add_subdirectory(test)
 endif()

package/vendor/libutf/include/utf/string.h

@@ -24,7 +24,10 @@ typedef struct utf8_string_view_s utf8_string_view_t;
 struct utf8_string_s {
   utf8_t *data;
   size_t len;
-  size_t cap;
+  union {
+    size_t cap;
+    utf8_t buf[8];
+  };
 };
 
 struct utf8_string_view_s {
@@ -34,9 +37,8 @@ struct utf8_string_view_s {
 
 inline void
 utf8_string_init (utf8_string_t *string) {
+  string->data = string->buf;
   string->len = 0;
-  string->cap = 0;
-  string->data = NULL;
 }
 
 inline utf8_string_view_t
@@ -46,41 +48,65 @@ utf8_string_view_init (const utf8_t *data, size_t len) {
 
 inline void
 utf8_string_destroy (utf8_string_t *string) {
-  free(string->data);
+  if (string->data != string->buf) free(string->data);
 }
 
 inline int
 utf8_string_reserve (utf8_string_t *string, size_t len) {
-  size_t cap = string->cap;
+  size_t cap = string->data == string->buf ? sizeof(string->buf) : string->cap;
 
-  if (len < cap) return 0;
+  if (len <= cap) return 0;
 
-  if (cap == 0) cap = sizeof(utf8_string_t) - 1;
+  // https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+  len--;
+  len |= len >> 1;
+  len |= len >> 2;
+  len |= len >> 4;
+  len |= len >> 8;
+  len |= len >> 16;
+  if (sizeof(len) == 8) len |= len >> 32;
+  len++;
 
-  while (cap < len) {
-    cap = cap * 2 + 1;
-  }
+  cap = len;
+
+  utf8_t *data;
 
-  void *data = realloc(string->data, cap);
+  if (string->data == string->buf) {
+    data = (utf8_t *) malloc(cap);
+
+    memcpy(data, string->data, string->len);
+  } else {
+    data = (utf8_t *) realloc(string->data, cap);
+  }
 
   if (data == NULL) return -1;
 
-  string->cap = cap;
   string->data = data;
+  string->cap = cap;
 
   return 0;
 }
 
 inline int
 utf8_string_shrink_to_fit (utf8_string_t *string) {
-  size_t cap = string->len + 1;
+  if (string->data == string->buf) return 0;
 
-  void *data = realloc(string->data, cap);
+  size_t cap = string->len;
 
-  if (data == NULL) return -1;
+  if (cap <= sizeof(string->buf)) {
+    memcpy(string->buf, string->data, cap);
 
-  string->cap = cap;
-  string->data = data;
+    free(string->data);
+
+    string->data = string->buf;
+  } else {
+    utf8_t *data = (utf8_t *) realloc(string->data, cap);
+
+    if (data == NULL) return -1;
+
+    string->data = data;
+    string->cap = cap;
+  }
 
   return 0;
 }
@@ -96,7 +122,7 @@ utf8_string_clear (utf8_string_t *string) {
 }
 
 inline bool
-utf8_string_empty (utf8_string_t *string) {
+utf8_string_empty (const utf8_string_t *string) {
   return string->len == 0;
 }
 

package/vendor/libutf/include/utf.h

@@ -11,6 +11,9 @@ extern "C" {
 
 typedef uint_least8_t utf8_t;
 typedef uint_least16_t utf16_t;
+typedef uint_least32_t utf32_t;
+typedef uint_least8_t latin1_t;
+typedef uint_least8_t ascii_t;
 
 /**
  * UTF-8
@@ -22,9 +25,21 @@ 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_length_from_utf32 (const utf32_t *data, size_t len);
+
+size_t
+utf8_length_from_latin1 (const latin1_t *data, size_t len);
+
 size_t
 utf8_convert_to_utf16le (const utf8_t *data, size_t len, utf16_t *result);
 
+size_t
+utf8_convert_to_utf32 (const utf8_t *data, size_t len, utf32_t *result);
+
+size_t
+utf8_convert_to_latin1 (const utf8_t *data, size_t len, latin1_t *result);
+
 /**
  * UTF-16
  */
@@ -35,9 +50,81 @@ utf16le_validate (const utf16_t *data, size_t len);
 size_t
 utf16_length_from_utf8 (const utf8_t *data, size_t len);
 
+size_t
+utf16_length_from_utf32 (const utf32_t *data, size_t len);
+
+size_t
+utf16_length_from_latin1 (const latin1_t *data, size_t len);
+
 size_t
 utf16le_convert_to_utf8 (const utf16_t *data, size_t len, utf8_t *result);
 
+size_t
+utf16le_convert_to_utf32 (const utf16_t *data, size_t len, utf32_t *result);
+
+size_t
+utf16le_convert_to_latin1 (const utf16_t *data, size_t len, latin1_t *result);
+
+/**
+ * UTF-32
+ */
+
+bool
+utf32_validate (const utf32_t *data, size_t len);
+
+size_t
+utf32_length_from_utf8 (const utf8_t *data, size_t len);
+
+size_t
+utf32_length_from_utf16le (const utf16_t *data, size_t len);
+
+size_t
+utf32_length_from_latin1 (const latin1_t *data, size_t len);
+
+size_t
+utf32_convert_to_utf8 (const utf32_t *data, size_t len, utf8_t *result);
+
+size_t
+utf32_convert_to_utf16le (const utf32_t *data, size_t len, utf16_t *result);
+
+size_t
+utf32_convert_to_latin1 (const utf32_t *data, size_t len, latin1_t *result);
+
+/**
+ * Latin-1
+ */
+
+size_t
+latin1_length_from_utf8 (const utf8_t *data, size_t len);
+
+size_t
+latin1_length_from_utf16le (const utf16_t *data, size_t len);
+
+size_t
+latin1_length_from_utf32 (const utf32_t *data, size_t len);
+
+size_t
+latin1_convert_to_utf8 (const latin1_t *data, size_t len, utf8_t *result);
+
+size_t
+latin1_convert_to_utf16le (const latin1_t *data, size_t len, utf16_t *result);
+
+size_t
+latin1_convert_to_utf32 (const latin1_t *data, size_t len, utf32_t *result);
+
+/**
+ * ASCII
+ */
+
+bool
+ascii_validate (const ascii_t *data, size_t len);
+
+/**
+ * Strings
+ */
+
+#include <utf/string.h>
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -0,0 +1,47 @@
+#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
+ascii_validate (const ascii_t *data, size_t len) {
+  uint64_t pos = 0;
+
+  for (; pos + 16 <= len; pos += 16) {
+    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) {
+      return false;
+    }
+  }
+  for (; pos < len; pos++) {
+    if (data[pos] >= 0b10000000) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/vendor/libutf/src/endianness.c

@@ -1,7 +1,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-#include "../include/utf/endianness.h"
+#include "endianness.h"
 
 extern utf_endianness_t
 utf_endianness (void);

package/vendor/libutf/src/latin1/convert-to-utf16.c

@@ -0,0 +1,37 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+#include "../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
+latin1_convert_to_utf16le (const latin1_t *data, size_t len, utf16_t *result) {
+  size_t pos = 0;
+  utf16_t *start = result;
+
+  while (pos < len) {
+    *result++ = utf_is_be() ? utf_swap_uint16(data[pos]) : data[pos];
+    pos++;
+  }
+
+  return result - start;
+}

package/vendor/libutf/src/latin1/convert-to-utf32.c

@@ -0,0 +1,34 @@
+#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.
+ */
+
+size_t
+latin1_convert_to_utf32 (const latin1_t *data, size_t len, utf32_t *result) {
+  utf32_t *start = result;
+
+  for (size_t i = 0; i < len; i++) {
+    *result++ = data[i];
+  }
+
+  return result - start;
+}

package/vendor/libutf/src/latin1/convert-to-utf8.c

@@ -0,0 +1,58 @@
+#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.
+ */
+
+size_t
+latin1_convert_to_utf8 (const latin1_t *data, size_t len, utf8_t *result) {
+  size_t pos = 0;
+  utf8_t *start = result;
+
+  while (pos < len) {
+    if (pos + 16 <= 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) {
+        size_t final_pos = pos + 16;
+        while (pos < final_pos) {
+          *result++ = data[pos];
+          pos++;
+        }
+        continue;
+      }
+    }
+    unsigned char byte = data[pos];
+    if ((byte & 0x80) == 0) {
+      *result++ = byte;
+      pos++;
+    } else {
+      *result++ = (byte >> 6) | 0b11000000;
+      *result++ = (byte & 0b111111) | 0b10000000;
+      pos++;
+    }
+  }
+
+  return result - start;
+}

package/vendor/libutf/src/latin1/length-from-utf16.c

@@ -0,0 +1,26 @@
+#include <stddef.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
+latin1_length_from_utf16le (const utf16_t *data, size_t len) {
+  return len;
+}