@unhead/schema-org 0.0.7 → 0.1.0

package/README.md

@@ -2,7 +2,7 @@
 
 Schema.org for Vue. Supports typed and automated Google Rich Results
 
-[Documentation](https://vue-schema-org.netlify.app/)
+[Documentation](https://unhead-schema-org.harlanzw.com//)
 
 ## License
 

package/dist/index.cjs

@@ -1,14 +1,73 @@
 'use strict';
 
-const ohash = require('ohash');
-const defu = require('defu');
-const ufo = require('ufo');
 const unhead = require('unhead');
 
 function defineSchemaOrgResolver(schema) {
   return schema;
 }
 
+const PROTOCOL_REGEX = /^\w{2,}:(\/\/)?/;
+const PROTOCOL_RELATIVE_REGEX = /^\/\/[^/]+/;
+function hasProtocol(inputString, acceptProtocolRelative = false) {
+  return PROTOCOL_REGEX.test(inputString) || acceptProtocolRelative && PROTOCOL_RELATIVE_REGEX.test(inputString);
+}
+const TRAILING_SLASH_RE = /\/$|\/\?/;
+function hasTrailingSlash(input = "", queryParameters = false) {
+  if (!queryParameters) {
+    return input.endsWith("/");
+  }
+  return TRAILING_SLASH_RE.test(input);
+}
+function withoutTrailingSlash(input = "", queryParameters = false) {
+  if (!queryParameters) {
+    return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
+  }
+  if (!hasTrailingSlash(input, true)) {
+    return input || "/";
+  }
+  const [s0, ...s] = input.split("?");
+  return (s0.slice(0, -1) || "/") + (s.length > 0 ? `?${s.join("?")}` : "");
+}
+function withTrailingSlash(input = "", queryParameters = false) {
+  if (!queryParameters) {
+    return input.endsWith("/") ? input : input + "/";
+  }
+  if (hasTrailingSlash(input, true)) {
+    return input || "/";
+  }
+  const [s0, ...s] = input.split("?");
+  return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "");
+}
+function hasLeadingSlash(input = "") {
+  return input.startsWith("/");
+}
+function withoutLeadingSlash(input = "") {
+  return (hasLeadingSlash(input) ? input.slice(1) : input) || "/";
+}
+function withBase(input, base) {
+  if (isEmptyURL(base) || hasProtocol(input)) {
+    return input;
+  }
+  const _base = withoutTrailingSlash(base);
+  if (input.startsWith(_base)) {
+    return input;
+  }
+  return joinURL(_base, input);
+}
+function isEmptyURL(url) {
+  return !url || url === "/";
+}
+function isNonEmptyURL(url) {
+  return url && url !== "/";
+}
+function joinURL(base, ...input) {
+  let url = base || "";
+  for (const index of input.filter((url2) => isNonEmptyURL(url2))) {
+    url = url ? withTrailingSlash(url) + withoutLeadingSlash(index) : index;
+  }
+  return url;
+}
+
 const idReference = (node) => ({
   "@id": typeof node !== "string" ? node["@id"] : node
 });
@@ -47,11 +106,11 @@ const dedupeMerge = (node, field, value) => {
   node[field] = [...data.values()].filter(Boolean);
 };
 const prefixId = (url, id) => {
-  if (ufo.hasProtocol(id))
+  if (hasProtocol(id))
     return url;
   if (!id.startsWith("#"))
     id = `#${id}`;
-  return ufo.joinURL(url, id);
+  return joinURL(url, id);
 };
 const trimLength = (val, length) => {
   if (!val)
@@ -73,9 +132,9 @@ const resolveDefaultType = (node, defaultType) => {
   node["@type"] = types.size === 1 ? val : [...types.values()];
 };
 const resolveWithBase = (base, urlOrPath) => {
-  if (!urlOrPath || ufo.hasProtocol(urlOrPath) || !urlOrPath.startsWith("/") && !urlOrPath.startsWith("#"))
+  if (!urlOrPath || hasProtocol(urlOrPath) || !urlOrPath.startsWith("/") && !urlOrPath.startsWith("#"))
     return urlOrPath;
-  return ufo.withBase(urlOrPath, base);
+  return withBase(urlOrPath, base);
 };
 const resolveAsGraphKey = (key) => {
   if (!key)
@@ -95,6 +154,12 @@ const stripEmptyProperties = (obj) => {
   });
   return obj;
 };
+function hashCode(s) {
+  let h = 9;
+  for (let i = 0; i < s.length; )
+    h = Math.imul(h ^ s.charCodeAt(i++), 9 ** 9);
+  return ((h ^ h >>> 9) + 65536).toString(16).substring(1, 8).toLowerCase();
+}
 
 const offerResolver = defineSchemaOrgResolver({
   cast(node) {
@@ -115,7 +180,7 @@ const offerResolver = defineSchemaOrgResolver({
     if (node.url)
       resolveWithBase(ctx.meta.host, node.url);
     if (node.availability)
-      node.availability = ufo.withBase(node.availability, "https://schema.org/");
+      node.availability = withBase(node.availability, "https://schema.org/");
     if (node.priceValidUntil)
       node.priceValidUntil = resolvableDateToIso(node.priceValidUntil);
     return node;
@@ -353,7 +418,7 @@ const readActionResolver = defineSchemaOrgResolver({
 const PrimaryWebPageId = "#webpage";
 const webPageResolver = defineSchemaOrgResolver({
   defaults({ meta }) {
-    const endPath = ufo.withoutTrailingSlash(meta.url.substring(meta.url.lastIndexOf("/") + 1));
+    const endPath = withoutTrailingSlash(meta.url.substring(meta.url.lastIndexOf("/") + 1));
     let type = "WebPage";
     switch (endPath) {
       case "about":
@@ -488,7 +553,7 @@ const bookEditionResolver = defineSchemaOrgResolver({
   ],
   resolve(node, ctx) {
     if (node.bookFormat)
-      node.bookFormat = ufo.withBase(node.bookFormat, "https://schema.org/");
+      node.bookFormat = withBase(node.bookFormat, "https://schema.org/");
     if (node.datePublished)
       node.datePublished = resolvableDateToDate(node.datePublished);
     node.author = resolveRelation(node.author, ctx);
@@ -516,7 +581,7 @@ const bookResolver = defineSchemaOrgResolver({
     node.workExample = resolveRelation(node.workExample, ctx, bookEditionResolver);
     node.author = resolveRelation(node.author, ctx);
     if (node.url)
-      ufo.withBase(node.url, ctx.meta.host);
+      withBase(node.url, ctx.meta.host);
     return node;
   },
   resolveRootNode(node, { find }) {
@@ -612,9 +677,9 @@ const eventResolver = defineSchemaOrgResolver({
     });
     node.offers = resolveRelation(node.offers, ctx, offerResolver);
     if (node.eventAttendanceMode)
-      node.eventAttendanceMode = ufo.withBase(node.eventAttendanceMode, "https://schema.org/");
+      node.eventAttendanceMode = withBase(node.eventAttendanceMode, "https://schema.org/");
     if (node.eventStatus)
-      node.eventStatus = ufo.withBase(node.eventStatus, "https://schema.org/");
+      node.eventStatus = withBase(node.eventStatus, "https://schema.org/");
     const isOnline = node.eventStatus === "https://schema.org/EventMovedOnline";
     const dates = ["startDate", "previousStartDate", "endDate"];
     dates.forEach((date) => {
@@ -793,6 +858,487 @@ const movieResolver = defineSchemaOrgResolver({
   }
 });
 
+const defaults = {
+  ignoreUnknown: false,
+  respectType: false,
+  respectFunctionNames: false,
+  respectFunctionProperties: false,
+  unorderedObjects: true,
+  unorderedArrays: false,
+  unorderedSets: false
+};
+function objectHash(object, options = {}) {
+  options = { ...defaults, ...options };
+  const hasher = createHasher(options);
+  hasher.dispatch(object);
+  return hasher.toString();
+}
+function createHasher(options) {
+  const buff = [];
+  let context = [];
+  const write = (str) => {
+    buff.push(str);
+  };
+  return {
+    toString() {
+      return buff.join("");
+    },
+    getContext() {
+      return context;
+    },
+    dispatch(value) {
+      if (options.replacer) {
+        value = options.replacer(value);
+      }
+      const type = value === null ? "null" : typeof value;
+      return this["_" + type](value);
+    },
+    _object(object) {
+      const pattern = /\[object (.*)]/i;
+      const objString = Object.prototype.toString.call(object);
+      const _objType = pattern.exec(objString);
+      const objType = _objType ? _objType[1].toLowerCase() : "unknown:[" + objString.toLowerCase() + "]";
+      let objectNumber = null;
+      if ((objectNumber = context.indexOf(object)) >= 0) {
+        return this.dispatch("[CIRCULAR:" + objectNumber + "]");
+      } else {
+        context.push(object);
+      }
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
+        write("buffer:");
+        return write(object.toString("utf8"));
+      }
+      if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
+        if (this["_" + objType]) {
+          this["_" + objType](object);
+        } else if (options.ignoreUnknown) {
+          return write("[" + objType + "]");
+        } else {
+          throw new Error('Unknown object type "' + objType + '"');
+        }
+      } else {
+        let keys = Object.keys(object);
+        if (options.unorderedObjects) {
+          keys = keys.sort();
+        }
+        if (options.respectType !== false && !isNativeFunction(object)) {
+          keys.splice(0, 0, "prototype", "__proto__", "letructor");
+        }
+        if (options.excludeKeys) {
+          keys = keys.filter(function(key) {
+            return !options.excludeKeys(key);
+          });
+        }
+        write("object:" + keys.length + ":");
+        for (const key of keys) {
+          this.dispatch(key);
+          write(":");
+          if (!options.excludeValues) {
+            this.dispatch(object[key]);
+          }
+          write(",");
+        }
+      }
+    },
+    _array(arr, unordered) {
+      unordered = typeof unordered !== "undefined" ? unordered : options.unorderedArrays !== false;
+      write("array:" + arr.length + ":");
+      if (!unordered || arr.length <= 1) {
+        for (const entry of arr) {
+          this.dispatch(entry);
+        }
+        return;
+      }
+      const contextAdditions = [];
+      const entries = arr.map((entry) => {
+        const hasher = createHasher(options);
+        hasher.dispatch(entry);
+        contextAdditions.push(hasher.getContext());
+        return hasher.toString();
+      });
+      context = [...context, ...contextAdditions];
+      entries.sort();
+      return this._array(entries, false);
+    },
+    _date(date) {
+      return write("date:" + date.toJSON());
+    },
+    _symbol(sym) {
+      return write("symbol:" + sym.toString());
+    },
+    _error(err) {
+      return write("error:" + err.toString());
+    },
+    _boolean(bool) {
+      return write("bool:" + bool.toString());
+    },
+    _string(string) {
+      write("string:" + string.length + ":");
+      write(string.toString());
+    },
+    _function(fn) {
+      write("fn:");
+      if (isNativeFunction(fn)) {
+        this.dispatch("[native]");
+      } else {
+        this.dispatch(fn.toString());
+      }
+      if (options.respectFunctionNames !== false) {
+        this.dispatch("function-name:" + String(fn.name));
+      }
+      if (options.respectFunctionProperties) {
+        this._object(fn);
+      }
+    },
+    _number(number) {
+      return write("number:" + number.toString());
+    },
+    _xml(xml) {
+      return write("xml:" + xml.toString());
+    },
+    _null() {
+      return write("Null");
+    },
+    _undefined() {
+      return write("Undefined");
+    },
+    _regexp(regex) {
+      return write("regex:" + regex.toString());
+    },
+    _uint8array(arr) {
+      write("uint8array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _uint8clampedarray(arr) {
+      write("uint8clampedarray:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _int8array(arr) {
+      write("int8array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _uint16array(arr) {
+      write("uint16array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _int16array(arr) {
+      write("int16array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _uint32array(arr) {
+      write("uint32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _int32array(arr) {
+      write("int32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _float32array(arr) {
+      write("float32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _float64array(arr) {
+      write("float64array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _arraybuffer(arr) {
+      write("arraybuffer:");
+      return this.dispatch(new Uint8Array(arr));
+    },
+    _url(url) {
+      return write("url:" + url.toString());
+    },
+    _map(map) {
+      write("map:");
+      const arr = [...map];
+      return this._array(arr, options.unorderedSets !== false);
+    },
+    _set(set) {
+      write("set:");
+      const arr = [...set];
+      return this._array(arr, options.unorderedSets !== false);
+    },
+    _file(file) {
+      write("file:");
+      return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
+    },
+    _blob() {
+      if (options.ignoreUnknown) {
+        return write("[blob]");
+      }
+      throw new Error('Hashing Blob objects is currently not supported\nUse "options.replacer" or "options.ignoreUnknown"\n');
+    },
+    _domwindow() {
+      return write("domwindow");
+    },
+    _bigint(number) {
+      return write("bigint:" + number.toString());
+    },
+    _process() {
+      return write("process");
+    },
+    _timer() {
+      return write("timer");
+    },
+    _pipe() {
+      return write("pipe");
+    },
+    _tcp() {
+      return write("tcp");
+    },
+    _udp() {
+      return write("udp");
+    },
+    _tty() {
+      return write("tty");
+    },
+    _statwatcher() {
+      return write("statwatcher");
+    },
+    _securecontext() {
+      return write("securecontext");
+    },
+    _connection() {
+      return write("connection");
+    },
+    _zlib() {
+      return write("zlib");
+    },
+    _context() {
+      return write("context");
+    },
+    _nodescript() {
+      return write("nodescript");
+    },
+    _httpparser() {
+      return write("httpparser");
+    },
+    _dataview() {
+      return write("dataview");
+    },
+    _signal() {
+      return write("signal");
+    },
+    _fsevent() {
+      return write("fsevent");
+    },
+    _tlswrap() {
+      return write("tlswrap");
+    }
+  };
+}
+function isNativeFunction(f) {
+  if (typeof f !== "function") {
+    return false;
+  }
+  const exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code]\s+}$/i;
+  return exp.exec(Function.prototype.toString.call(f)) != null;
+}
+
+class WordArray {
+  constructor(words, sigBytes) {
+    words = this.words = words || [];
+    this.sigBytes = sigBytes !== void 0 ? sigBytes : words.length * 4;
+  }
+  toString(encoder) {
+    return (encoder || Hex).stringify(this);
+  }
+  concat(wordArray) {
+    this.clamp();
+    if (this.sigBytes % 4) {
+      for (let i = 0; i < wordArray.sigBytes; i++) {
+        const thatByte = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+        this.words[this.sigBytes + i >>> 2] |= thatByte << 24 - (this.sigBytes + i) % 4 * 8;
+      }
+    } else {
+      for (let j = 0; j < wordArray.sigBytes; j += 4) {
+        this.words[this.sigBytes + j >>> 2] = wordArray.words[j >>> 2];
+      }
+    }
+    this.sigBytes += wordArray.sigBytes;
+    return this;
+  }
+  clamp() {
+    this.words[this.sigBytes >>> 2] &= 4294967295 << 32 - this.sigBytes % 4 * 8;
+    this.words.length = Math.ceil(this.sigBytes / 4);
+  }
+  clone() {
+    return new WordArray([...this.words]);
+  }
+}
+const Hex = {
+  stringify(wordArray) {
+    const hexChars = [];
+    for (let i = 0; i < wordArray.sigBytes; i++) {
+      const bite = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+      hexChars.push(
+        (bite >>> 4).toString(16),
+        (bite & 15).toString(16)
+      );
+    }
+    return hexChars.join("");
+  }
+};
+const Base64 = {
+  stringify(wordArray) {
+    const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    const base64Chars = [];
+    for (let i = 0; i < wordArray.sigBytes; i += 3) {
+      const byte1 = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+      const byte2 = wordArray.words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;
+      const byte3 = wordArray.words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;
+      const triplet = byte1 << 16 | byte2 << 8 | byte3;
+      for (let j = 0; j < 4 && i * 8 + j * 6 < wordArray.sigBytes * 8; j++) {
+        base64Chars.push(keyStr.charAt(triplet >>> 6 * (3 - j) & 63));
+      }
+    }
+    return base64Chars.join("");
+  }
+};
+const Latin1 = {
+  parse(latin1Str) {
+    const latin1StrLength = latin1Str.length;
+    const words = [];
+    for (let i = 0; i < latin1StrLength; i++) {
+      words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;
+    }
+    return new WordArray(words, latin1StrLength);
+  }
+};
+const Utf8 = {
+  parse(utf8Str) {
+    return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+  }
+};
+class BufferedBlockAlgorithm {
+  constructor() {
+    this._minBufferSize = 0;
+    this.blockSize = 512 / 32;
+    this.reset();
+  }
+  reset() {
+    this._data = new WordArray();
+    this._nDataBytes = 0;
+  }
+  _append(data) {
+    if (typeof data === "string") {
+      data = Utf8.parse(data);
+    }
+    this._data.concat(data);
+    this._nDataBytes += data.sigBytes;
+  }
+  _doProcessBlock(_dataWords, _offset) {
+  }
+  _process(doFlush) {
+    let processedWords;
+    let nBlocksReady = this._data.sigBytes / (this.blockSize * 4);
+    if (doFlush) {
+      nBlocksReady = Math.ceil(nBlocksReady);
+    } else {
+      nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
+    }
+    const nWordsReady = nBlocksReady * this.blockSize;
+    const nBytesReady = Math.min(nWordsReady * 4, this._data.sigBytes);
+    if (nWordsReady) {
+      for (let offset = 0; offset < nWordsReady; offset += this.blockSize) {
+        this._doProcessBlock(this._data.words, offset);
+      }
+      processedWords = this._data.words.splice(0, nWordsReady);
+      this._data.sigBytes -= nBytesReady;
+    }
+    return new WordArray(processedWords, nBytesReady);
+  }
+}
+class Hasher extends BufferedBlockAlgorithm {
+  update(messageUpdate) {
+    this._append(messageUpdate);
+    this._process();
+    return this;
+  }
+  finalize(messageUpdate) {
+    if (messageUpdate) {
+      this._append(messageUpdate);
+    }
+  }
+}
+
+const H = [1779033703, -1150833019, 1013904242, -1521486534, 1359893119, -1694144372, 528734635, 1541459225];
+const K = [1116352408, 1899447441, -1245643825, -373957723, 961987163, 1508970993, -1841331548, -1424204075, -670586216, 310598401, 607225278, 1426881987, 1925078388, -2132889090, -1680079193, -1046744716, -459576895, -272742522, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, -1740746414, -1473132947, -1341970488, -1084653625, -958395405, -710438585, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, -2117940946, -1838011259, -1564481375, -1474664885, -1035236496, -949202525, -778901479, -694614492, -200395387, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, -2067236844, -1933114872, -1866530822, -1538233109, -1090935817, -965641998];
+const W = [];
+class SHA256 extends Hasher {
+  constructor() {
+    super();
+    this.reset();
+  }
+  reset() {
+    super.reset();
+    this._hash = new WordArray([...H]);
+  }
+  _doProcessBlock(M, offset) {
+    const H2 = this._hash.words;
+    let a = H2[0];
+    let b = H2[1];
+    let c = H2[2];
+    let d = H2[3];
+    let e = H2[4];
+    let f = H2[5];
+    let g = H2[6];
+    let h = H2[7];
+    for (let i = 0; i < 64; i++) {
+      if (i < 16) {
+        W[i] = M[offset + i] | 0;
+      } else {
+        const gamma0x = W[i - 15];
+        const gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;
+        const gamma1x = W[i - 2];
+        const gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;
+        W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
+      }
+      const ch = e & f ^ ~e & g;
+      const maj = a & b ^ a & c ^ b & c;
+      const sigma0 = (a << 30 | a >>> 2) ^ (a << 19 | a >>> 13) ^ (a << 10 | a >>> 22);
+      const sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);
+      const t1 = h + sigma1 + ch + K[i] + W[i];
+      const t2 = sigma0 + maj;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    H2[0] = H2[0] + a | 0;
+    H2[1] = H2[1] + b | 0;
+    H2[2] = H2[2] + c | 0;
+    H2[3] = H2[3] + d | 0;
+    H2[4] = H2[4] + e | 0;
+    H2[5] = H2[5] + f | 0;
+    H2[6] = H2[6] + g | 0;
+    H2[7] = H2[7] + h | 0;
+  }
+  finalize(messageUpdate) {
+    super.finalize(messageUpdate);
+    const nBitsTotal = this._nDataBytes * 8;
+    const nBitsLeft = this._data.sigBytes * 8;
+    this._data.words[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(nBitsTotal / 4294967296);
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
+    this._data.sigBytes = this._data.words.length * 4;
+    this._process();
+    return this._hash;
+  }
+}
+function sha256base64(message) {
+  return new SHA256().finalize(message).toString(Base64);
+}
+
+function hash(object, options = {}) {
+  const hashed = typeof object === "string" ? object : objectHash(object, options);
+  return sha256base64(hashed).slice(0, 10);
+}
+
 const ProductId = "#product";
 const productResolver = defineSchemaOrgResolver({
   defaults: {
@@ -805,7 +1351,7 @@ const productResolver = defineSchemaOrgResolver({
   ],
   idPrefix: ["url", ProductId],
   resolve(node, ctx) {
-    setIfEmpty(node, "sku", ohash.hash(node.name));
+    setIfEmpty(node, "sku", hash(node.name));
     node.aggregateOffer = resolveRelation(node.aggregateOffer, ctx, aggregateOfferResolver);
     node.aggregateRating = resolveRelation(node.aggregateRating, ctx, aggregateRatingResolver);
     node.offers = resolveRelation(node.offers, ctx, offerResolver);
@@ -1033,7 +1579,7 @@ const resolveMeta = (meta) => {
     meta.host = document.location.host;
   if (!meta.url && meta.canonicalUrl)
     meta.url = meta.canonicalUrl;
-  meta.url = ufo.joinURL(meta.host, meta.path);
+  meta.url = joinURL(meta.host, meta.path);
   return {
     host: meta.host,
     url: meta.url,
@@ -1053,7 +1599,10 @@ const resolveNode = (node, ctx, resolver) => {
     let defaults = resolver.defaults || {};
     if (typeof defaults === "function")
       defaults = defaults(ctx);
-    node = defu.defu(node, defaults);
+    node = {
+      ...defaults,
+      ...node
+    };
   }
   resolver.inheritMeta?.forEach((entry) => {
     if (typeof entry === "string")
@@ -1094,7 +1643,7 @@ const resolveNodeId = (node, ctx, resolver, resolveAsRoot = false) => {
       if (!key.startsWith("_"))
         hashNodeData[key] = val;
     });
-    node["@id"] = prefixId(ctx.meta[prefix], `#/schema/${alias}/${ohash.hash(hashNodeData)}`);
+    node["@id"] = prefixId(ctx.meta[prefix], `#/schema/${alias}/${hashCode(JSON.stringify(hashNodeData))}`);
   }
   return node;
 };
@@ -1143,7 +1692,7 @@ const dedupeNodes = (nodes) => {
   const dedupedNodes = {};
   for (const key of sortedNodeKeys) {
     const n = nodes[key];
-    const nodeKey = resolveAsGraphKey(n["@id"] || ohash.hash(n));
+    const nodeKey = resolveAsGraphKey(n["@id"] || hash(n));
     const groupedKeys = groupBy(Object.keys(n), (key2) => {
       const val = n[key2];
       if (key2.startsWith("_"))

package/dist/index.mjs

@@ -1,12 +1,71 @@
-import { hash } from 'ohash';
-import { defu } from 'defu';
-import { hasProtocol, joinURL, withBase, withoutTrailingSlash } from 'ufo';
 import { useHead } from 'unhead';
 
 function defineSchemaOrgResolver(schema) {
   return schema;
 }
 
+const PROTOCOL_REGEX = /^\w{2,}:(\/\/)?/;
+const PROTOCOL_RELATIVE_REGEX = /^\/\/[^/]+/;
+function hasProtocol(inputString, acceptProtocolRelative = false) {
+  return PROTOCOL_REGEX.test(inputString) || acceptProtocolRelative && PROTOCOL_RELATIVE_REGEX.test(inputString);
+}
+const TRAILING_SLASH_RE = /\/$|\/\?/;
+function hasTrailingSlash(input = "", queryParameters = false) {
+  if (!queryParameters) {
+    return input.endsWith("/");
+  }
+  return TRAILING_SLASH_RE.test(input);
+}
+function withoutTrailingSlash(input = "", queryParameters = false) {
+  if (!queryParameters) {
+    return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
+  }
+  if (!hasTrailingSlash(input, true)) {
+    return input || "/";
+  }
+  const [s0, ...s] = input.split("?");
+  return (s0.slice(0, -1) || "/") + (s.length > 0 ? `?${s.join("?")}` : "");
+}
+function withTrailingSlash(input = "", queryParameters = false) {
+  if (!queryParameters) {
+    return input.endsWith("/") ? input : input + "/";
+  }
+  if (hasTrailingSlash(input, true)) {
+    return input || "/";
+  }
+  const [s0, ...s] = input.split("?");
+  return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "");
+}
+function hasLeadingSlash(input = "") {
+  return input.startsWith("/");
+}
+function withoutLeadingSlash(input = "") {
+  return (hasLeadingSlash(input) ? input.slice(1) : input) || "/";
+}
+function withBase(input, base) {
+  if (isEmptyURL(base) || hasProtocol(input)) {
+    return input;
+  }
+  const _base = withoutTrailingSlash(base);
+  if (input.startsWith(_base)) {
+    return input;
+  }
+  return joinURL(_base, input);
+}
+function isEmptyURL(url) {
+  return !url || url === "/";
+}
+function isNonEmptyURL(url) {
+  return url && url !== "/";
+}
+function joinURL(base, ...input) {
+  let url = base || "";
+  for (const index of input.filter((url2) => isNonEmptyURL(url2))) {
+    url = url ? withTrailingSlash(url) + withoutLeadingSlash(index) : index;
+  }
+  return url;
+}
+
 const idReference = (node) => ({
   "@id": typeof node !== "string" ? node["@id"] : node
 });
@@ -93,6 +152,12 @@ const stripEmptyProperties = (obj) => {
   });
   return obj;
 };
+function hashCode(s) {
+  let h = 9;
+  for (let i = 0; i < s.length; )
+    h = Math.imul(h ^ s.charCodeAt(i++), 9 ** 9);
+  return ((h ^ h >>> 9) + 65536).toString(16).substring(1, 8).toLowerCase();
+}
 
 const offerResolver = defineSchemaOrgResolver({
   cast(node) {
@@ -791,6 +856,487 @@ const movieResolver = defineSchemaOrgResolver({
   }
 });
 
+const defaults = {
+  ignoreUnknown: false,
+  respectType: false,
+  respectFunctionNames: false,
+  respectFunctionProperties: false,
+  unorderedObjects: true,
+  unorderedArrays: false,
+  unorderedSets: false
+};
+function objectHash(object, options = {}) {
+  options = { ...defaults, ...options };
+  const hasher = createHasher(options);
+  hasher.dispatch(object);
+  return hasher.toString();
+}
+function createHasher(options) {
+  const buff = [];
+  let context = [];
+  const write = (str) => {
+    buff.push(str);
+  };
+  return {
+    toString() {
+      return buff.join("");
+    },
+    getContext() {
+      return context;
+    },
+    dispatch(value) {
+      if (options.replacer) {
+        value = options.replacer(value);
+      }
+      const type = value === null ? "null" : typeof value;
+      return this["_" + type](value);
+    },
+    _object(object) {
+      const pattern = /\[object (.*)]/i;
+      const objString = Object.prototype.toString.call(object);
+      const _objType = pattern.exec(objString);
+      const objType = _objType ? _objType[1].toLowerCase() : "unknown:[" + objString.toLowerCase() + "]";
+      let objectNumber = null;
+      if ((objectNumber = context.indexOf(object)) >= 0) {
+        return this.dispatch("[CIRCULAR:" + objectNumber + "]");
+      } else {
+        context.push(object);
+      }
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
+        write("buffer:");
+        return write(object.toString("utf8"));
+      }
+      if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
+        if (this["_" + objType]) {
+          this["_" + objType](object);
+        } else if (options.ignoreUnknown) {
+          return write("[" + objType + "]");
+        } else {
+          throw new Error('Unknown object type "' + objType + '"');
+        }
+      } else {
+        let keys = Object.keys(object);
+        if (options.unorderedObjects) {
+          keys = keys.sort();
+        }
+        if (options.respectType !== false && !isNativeFunction(object)) {
+          keys.splice(0, 0, "prototype", "__proto__", "letructor");
+        }
+        if (options.excludeKeys) {
+          keys = keys.filter(function(key) {
+            return !options.excludeKeys(key);
+          });
+        }
+        write("object:" + keys.length + ":");
+        for (const key of keys) {
+          this.dispatch(key);
+          write(":");
+          if (!options.excludeValues) {
+            this.dispatch(object[key]);
+          }
+          write(",");
+        }
+      }
+    },
+    _array(arr, unordered) {
+      unordered = typeof unordered !== "undefined" ? unordered : options.unorderedArrays !== false;
+      write("array:" + arr.length + ":");
+      if (!unordered || arr.length <= 1) {
+        for (const entry of arr) {
+          this.dispatch(entry);
+        }
+        return;
+      }
+      const contextAdditions = [];
+      const entries = arr.map((entry) => {
+        const hasher = createHasher(options);
+        hasher.dispatch(entry);
+        contextAdditions.push(hasher.getContext());
+        return hasher.toString();
+      });
+      context = [...context, ...contextAdditions];
+      entries.sort();
+      return this._array(entries, false);
+    },
+    _date(date) {
+      return write("date:" + date.toJSON());
+    },
+    _symbol(sym) {
+      return write("symbol:" + sym.toString());
+    },
+    _error(err) {
+      return write("error:" + err.toString());
+    },
+    _boolean(bool) {
+      return write("bool:" + bool.toString());
+    },
+    _string(string) {
+      write("string:" + string.length + ":");
+      write(string.toString());
+    },
+    _function(fn) {
+      write("fn:");
+      if (isNativeFunction(fn)) {
+        this.dispatch("[native]");
+      } else {
+        this.dispatch(fn.toString());
+      }
+      if (options.respectFunctionNames !== false) {
+        this.dispatch("function-name:" + String(fn.name));
+      }
+      if (options.respectFunctionProperties) {
+        this._object(fn);
+      }
+    },
+    _number(number) {
+      return write("number:" + number.toString());
+    },
+    _xml(xml) {
+      return write("xml:" + xml.toString());
+    },
+    _null() {
+      return write("Null");
+    },
+    _undefined() {
+      return write("Undefined");
+    },
+    _regexp(regex) {
+      return write("regex:" + regex.toString());
+    },
+    _uint8array(arr) {
+      write("uint8array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _uint8clampedarray(arr) {
+      write("uint8clampedarray:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _int8array(arr) {
+      write("int8array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _uint16array(arr) {
+      write("uint16array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _int16array(arr) {
+      write("int16array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _uint32array(arr) {
+      write("uint32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _int32array(arr) {
+      write("int32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _float32array(arr) {
+      write("float32array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _float64array(arr) {
+      write("float64array:");
+      return this.dispatch(Array.prototype.slice.call(arr));
+    },
+    _arraybuffer(arr) {
+      write("arraybuffer:");
+      return this.dispatch(new Uint8Array(arr));
+    },
+    _url(url) {
+      return write("url:" + url.toString());
+    },
+    _map(map) {
+      write("map:");
+      const arr = [...map];
+      return this._array(arr, options.unorderedSets !== false);
+    },
+    _set(set) {
+      write("set:");
+      const arr = [...set];
+      return this._array(arr, options.unorderedSets !== false);
+    },
+    _file(file) {
+      write("file:");
+      return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
+    },
+    _blob() {
+      if (options.ignoreUnknown) {
+        return write("[blob]");
+      }
+      throw new Error('Hashing Blob objects is currently not supported\nUse "options.replacer" or "options.ignoreUnknown"\n');
+    },
+    _domwindow() {
+      return write("domwindow");
+    },
+    _bigint(number) {
+      return write("bigint:" + number.toString());
+    },
+    _process() {
+      return write("process");
+    },
+    _timer() {
+      return write("timer");
+    },
+    _pipe() {
+      return write("pipe");
+    },
+    _tcp() {
+      return write("tcp");
+    },
+    _udp() {
+      return write("udp");
+    },
+    _tty() {
+      return write("tty");
+    },
+    _statwatcher() {
+      return write("statwatcher");
+    },
+    _securecontext() {
+      return write("securecontext");
+    },
+    _connection() {
+      return write("connection");
+    },
+    _zlib() {
+      return write("zlib");
+    },
+    _context() {
+      return write("context");
+    },
+    _nodescript() {
+      return write("nodescript");
+    },
+    _httpparser() {
+      return write("httpparser");
+    },
+    _dataview() {
+      return write("dataview");
+    },
+    _signal() {
+      return write("signal");
+    },
+    _fsevent() {
+      return write("fsevent");
+    },
+    _tlswrap() {
+      return write("tlswrap");
+    }
+  };
+}
+function isNativeFunction(f) {
+  if (typeof f !== "function") {
+    return false;
+  }
+  const exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code]\s+}$/i;
+  return exp.exec(Function.prototype.toString.call(f)) != null;
+}
+
+class WordArray {
+  constructor(words, sigBytes) {
+    words = this.words = words || [];
+    this.sigBytes = sigBytes !== void 0 ? sigBytes : words.length * 4;
+  }
+  toString(encoder) {
+    return (encoder || Hex).stringify(this);
+  }
+  concat(wordArray) {
+    this.clamp();
+    if (this.sigBytes % 4) {
+      for (let i = 0; i < wordArray.sigBytes; i++) {
+        const thatByte = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+        this.words[this.sigBytes + i >>> 2] |= thatByte << 24 - (this.sigBytes + i) % 4 * 8;
+      }
+    } else {
+      for (let j = 0; j < wordArray.sigBytes; j += 4) {
+        this.words[this.sigBytes + j >>> 2] = wordArray.words[j >>> 2];
+      }
+    }
+    this.sigBytes += wordArray.sigBytes;
+    return this;
+  }
+  clamp() {
+    this.words[this.sigBytes >>> 2] &= 4294967295 << 32 - this.sigBytes % 4 * 8;
+    this.words.length = Math.ceil(this.sigBytes / 4);
+  }
+  clone() {
+    return new WordArray([...this.words]);
+  }
+}
+const Hex = {
+  stringify(wordArray) {
+    const hexChars = [];
+    for (let i = 0; i < wordArray.sigBytes; i++) {
+      const bite = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+      hexChars.push(
+        (bite >>> 4).toString(16),
+        (bite & 15).toString(16)
+      );
+    }
+    return hexChars.join("");
+  }
+};
+const Base64 = {
+  stringify(wordArray) {
+    const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    const base64Chars = [];
+    for (let i = 0; i < wordArray.sigBytes; i += 3) {
+      const byte1 = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+      const byte2 = wordArray.words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;
+      const byte3 = wordArray.words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;
+      const triplet = byte1 << 16 | byte2 << 8 | byte3;
+      for (let j = 0; j < 4 && i * 8 + j * 6 < wordArray.sigBytes * 8; j++) {
+        base64Chars.push(keyStr.charAt(triplet >>> 6 * (3 - j) & 63));
+      }
+    }
+    return base64Chars.join("");
+  }
+};
+const Latin1 = {
+  parse(latin1Str) {
+    const latin1StrLength = latin1Str.length;
+    const words = [];
+    for (let i = 0; i < latin1StrLength; i++) {
+      words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;
+    }
+    return new WordArray(words, latin1StrLength);
+  }
+};
+const Utf8 = {
+  parse(utf8Str) {
+    return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+  }
+};
+class BufferedBlockAlgorithm {
+  constructor() {
+    this._minBufferSize = 0;
+    this.blockSize = 512 / 32;
+    this.reset();
+  }
+  reset() {
+    this._data = new WordArray();
+    this._nDataBytes = 0;
+  }
+  _append(data) {
+    if (typeof data === "string") {
+      data = Utf8.parse(data);
+    }
+    this._data.concat(data);
+    this._nDataBytes += data.sigBytes;
+  }
+  _doProcessBlock(_dataWords, _offset) {
+  }
+  _process(doFlush) {
+    let processedWords;
+    let nBlocksReady = this._data.sigBytes / (this.blockSize * 4);
+    if (doFlush) {
+      nBlocksReady = Math.ceil(nBlocksReady);
+    } else {
+      nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
+    }
+    const nWordsReady = nBlocksReady * this.blockSize;
+    const nBytesReady = Math.min(nWordsReady * 4, this._data.sigBytes);
+    if (nWordsReady) {
+      for (let offset = 0; offset < nWordsReady; offset += this.blockSize) {
+        this._doProcessBlock(this._data.words, offset);
+      }
+      processedWords = this._data.words.splice(0, nWordsReady);
+      this._data.sigBytes -= nBytesReady;
+    }
+    return new WordArray(processedWords, nBytesReady);
+  }
+}
+class Hasher extends BufferedBlockAlgorithm {
+  update(messageUpdate) {
+    this._append(messageUpdate);
+    this._process();
+    return this;
+  }
+  finalize(messageUpdate) {
+    if (messageUpdate) {
+      this._append(messageUpdate);
+    }
+  }
+}
+
+const H = [1779033703, -1150833019, 1013904242, -1521486534, 1359893119, -1694144372, 528734635, 1541459225];
+const K = [1116352408, 1899447441, -1245643825, -373957723, 961987163, 1508970993, -1841331548, -1424204075, -670586216, 310598401, 607225278, 1426881987, 1925078388, -2132889090, -1680079193, -1046744716, -459576895, -272742522, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, -1740746414, -1473132947, -1341970488, -1084653625, -958395405, -710438585, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, -2117940946, -1838011259, -1564481375, -1474664885, -1035236496, -949202525, -778901479, -694614492, -200395387, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, -2067236844, -1933114872, -1866530822, -1538233109, -1090935817, -965641998];
+const W = [];
+class SHA256 extends Hasher {
+  constructor() {
+    super();
+    this.reset();
+  }
+  reset() {
+    super.reset();
+    this._hash = new WordArray([...H]);
+  }
+  _doProcessBlock(M, offset) {
+    const H2 = this._hash.words;
+    let a = H2[0];
+    let b = H2[1];
+    let c = H2[2];
+    let d = H2[3];
+    let e = H2[4];
+    let f = H2[5];
+    let g = H2[6];
+    let h = H2[7];
+    for (let i = 0; i < 64; i++) {
+      if (i < 16) {
+        W[i] = M[offset + i] | 0;
+      } else {
+        const gamma0x = W[i - 15];
+        const gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;
+        const gamma1x = W[i - 2];
+        const gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;
+        W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
+      }
+      const ch = e & f ^ ~e & g;
+      const maj = a & b ^ a & c ^ b & c;
+      const sigma0 = (a << 30 | a >>> 2) ^ (a << 19 | a >>> 13) ^ (a << 10 | a >>> 22);
+      const sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);
+      const t1 = h + sigma1 + ch + K[i] + W[i];
+      const t2 = sigma0 + maj;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    H2[0] = H2[0] + a | 0;
+    H2[1] = H2[1] + b | 0;
+    H2[2] = H2[2] + c | 0;
+    H2[3] = H2[3] + d | 0;
+    H2[4] = H2[4] + e | 0;
+    H2[5] = H2[5] + f | 0;
+    H2[6] = H2[6] + g | 0;
+    H2[7] = H2[7] + h | 0;
+  }
+  finalize(messageUpdate) {
+    super.finalize(messageUpdate);
+    const nBitsTotal = this._nDataBytes * 8;
+    const nBitsLeft = this._data.sigBytes * 8;
+    this._data.words[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(nBitsTotal / 4294967296);
+    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
+    this._data.sigBytes = this._data.words.length * 4;
+    this._process();
+    return this._hash;
+  }
+}
+function sha256base64(message) {
+  return new SHA256().finalize(message).toString(Base64);
+}
+
+function hash(object, options = {}) {
+  const hashed = typeof object === "string" ? object : objectHash(object, options);
+  return sha256base64(hashed).slice(0, 10);
+}
+
 const ProductId = "#product";
 const productResolver = defineSchemaOrgResolver({
   defaults: {
@@ -1051,7 +1597,10 @@ const resolveNode = (node, ctx, resolver) => {
     let defaults = resolver.defaults || {};
     if (typeof defaults === "function")
       defaults = defaults(ctx);
-    node = defu(node, defaults);
+    node = {
+      ...defaults,
+      ...node
+    };
   }
   resolver.inheritMeta?.forEach((entry) => {
     if (typeof entry === "string")
@@ -1092,7 +1641,7 @@ const resolveNodeId = (node, ctx, resolver, resolveAsRoot = false) => {
       if (!key.startsWith("_"))
         hashNodeData[key] = val;
     });
-    node["@id"] = prefixId(ctx.meta[prefix], `#/schema/${alias}/${hash(hashNodeData)}`);
+    node["@id"] = prefixId(ctx.meta[prefix], `#/schema/${alias}/${hashCode(JSON.stringify(hashNodeData))}`);
   }
   return node;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unhead/schema-org",
-  "version": "0.0.7",
+  "version": "0.1.0",
   "packageManager": "pnpm@7.8.0",
   "description": "Node Schema.org for Simple and Automated Google Rich Results",
   "author": "Harlan Wilton <harlan@harlanzw.com>",
@@ -34,14 +34,10 @@
     "dist"
   ],
   "peerDependencies": {
-    "unhead": ">=1.0.8"
-  },
-  "dependencies": {
-    "defu": "^6.1.1",
-    "ohash": "^1.0.0",
-    "ufo": "^1.0.1"
+    "unhead": ">=1.0.9"
   },
   "devDependencies": {
+    "ufo": "^1.0.1",
     "unhead": "latest"
   },
   "scripts": {