@warp-drive/experiments 0.2.6-alpha.4 → 0.2.6-alpha.41

package/dist/unpkg/prod-deprecated/document-storage.js

@@ -0,0 +1,339 @@
+const WARP_DRIVE_STORAGE_FILE_NAME = 'warp-drive_document-storage';
+const WARP_DRIVE_STORAGE_VERSION = 1;
+
+/**
+ * DocumentStorage is specifically designed around WarpDrive Cache and Request concepts.
+ *
+ * CacheFileDocument is a StructuredDocument (request response) whose `content` is
+ * the ResourceDocument returned by inserting the request into a Store's Cache.
+ */
+
+/**
+ * A CacheDocument is a reconstructed request response that rehydrates ResourceDocument
+ * with the associated resources based on their identifiers.
+ */
+
+class InternalDocumentStorage {
+  constructor(options) {
+    this.options = options;
+    this._lastModified = 0;
+    this._invalidated = true;
+    this._fileHandle = this._open(options.scope);
+    this._channel = Object.assign(new BroadcastChannel(options.scope), {
+      onmessage: this._onMessage.bind(this)
+    });
+  }
+  _onMessage(_event) {
+    this._invalidated = true;
+  }
+  async _open(scope) {
+    const directoryHandle = await navigator.storage.getDirectory();
+    const fileHandle = await directoryHandle.getFileHandle(scope, {
+      create: true
+    });
+    return fileHandle;
+  }
+  async _read() {
+    if (this._filePromise) {
+      return this._filePromise;
+    }
+    if (this._invalidated) {
+      const updateFile = async () => {
+        const fileHandle = await this._fileHandle;
+        const file = await fileHandle.getFile();
+        const lastModified = file.lastModified;
+        if (lastModified === this._lastModified && this._cache) {
+          return this._cache;
+        }
+        const contents = await file.text();
+        const cache = contents ? JSON.parse(contents) : {
+          documents: [],
+          resources: []
+        };
+        const documents = new Map(cache.documents);
+        const resources = new Map(cache.resources);
+        const cacheMap = {
+          documents,
+          resources
+        };
+        this._cache = cacheMap;
+        this._invalidated = false;
+        this._lastModified = lastModified;
+        return cacheMap;
+      };
+      this._filePromise = updateFile();
+      await this._filePromise;
+      this._filePromise = null;
+    }
+    return this._cache;
+  }
+  async _patch(documentKey, document, updatedResources) {
+    const fileHandle = await this._fileHandle;
+    // secure a lock before getting latest state
+    const writable = await fileHandle.createWritable();
+    const cache = await this._read();
+    cache.documents.set(documentKey, document);
+    updatedResources.forEach((resource, key) => {
+      cache.resources.set(key, resource);
+    });
+    const documents = [...cache.documents.entries()];
+    const resources = [...cache.resources.entries()];
+    const cacheFile = {
+      documents,
+      resources
+    };
+    await writable.write(JSON.stringify(cacheFile));
+    await writable.close();
+    this._channel.postMessage({
+      type: 'patch',
+      key: documentKey,
+      resources: [...updatedResources.keys()]
+    });
+  }
+  async getDocument(key) {
+    const cache = await this._read();
+    // clone the document to avoid leaking the internal cache
+    const document = safeDocumentHydrate(cache.documents.get(key.lid));
+    if (!document) {
+      return null;
+    }
+
+    // expand the document with the resources
+    if (document.content) {
+      if (docHasData(document.content)) {
+        let data = null;
+        if (Array.isArray(document.content.data)) {
+          data = document.content.data.map(resourceIdentifier => {
+            const resource = cache.resources.get(resourceIdentifier.lid);
+            if (!resource) {
+              throw new Error(`Resource not found for ${resourceIdentifier.lid}`);
+            }
+
+            // clone the resource to avoid leaking the internal cache
+            return structuredClone(resource);
+          });
+        } else if (document.content.data) {
+          const resource = cache.resources.get(document.content.data.lid);
+          if (!resource) {
+            throw new Error(`Resource not found for ${document.content.data.lid}`);
+          }
+
+          // clone the resource to avoid leaking the internal cache
+          data = structuredClone(resource);
+        }
+        if (document.content.included) {
+          const included = document.content.included.map(resourceIdentifier => {
+            const resource = cache.resources.get(resourceIdentifier.lid);
+            if (!resource) {
+              throw new Error(`Resource not found for ${resourceIdentifier.lid}`);
+            }
+
+            // clone the resource to avoid leaking the internal cache
+            return structuredClone(resource);
+          });
+          document.content.included = included;
+        }
+        document.content.data = data;
+      }
+    }
+    return document;
+  }
+  async putDocument(document, resourceCollector) {
+    const resources = new Map();
+    if (!document.content) {
+      throw new Error(`Document content is missing, only finalized documents can be stored`);
+    }
+    if (!document.content.lid) {
+      throw new Error(`Document content is missing a lid, only documents with a cache-key can be stored`);
+    }
+    if (docHasData(document.content)) {
+      this._getResources(document.content, resourceCollector, resources);
+    }
+    await this._patch(document.content.lid, safeDocumentSerialize(document), resources);
+  }
+  _getResources(document, resourceCollector, resources = new Map()) {
+    if (Array.isArray(document.data)) {
+      document.data.forEach(resourceIdentifier => {
+        const resource = resourceCollector(resourceIdentifier);
+        resources.set(resourceIdentifier.lid, structuredClone(resource));
+      });
+    } else if (document.data) {
+      const resource = resourceCollector(document.data);
+      resources.set(document.data.lid, structuredClone(resource));
+    }
+    if (document.included) {
+      document.included.forEach(resourceIdentifier => {
+        const resource = resourceCollector(resourceIdentifier);
+        resources.set(resourceIdentifier.lid, structuredClone(resource));
+      });
+    }
+    return resources;
+  }
+  async putResources(document, resourceCollector) {
+    const fileHandle = await this._fileHandle;
+    // secure a lock before getting latest state
+    const writable = await fileHandle.createWritable();
+    const cache = await this._read();
+    const updatedResources = this._getResources(document, resourceCollector);
+    updatedResources.forEach((resource, key) => {
+      cache.resources.set(key, resource);
+    });
+    const documents = [...cache.documents.entries()];
+    const resources = [...cache.resources.entries()];
+    const cacheFile = {
+      documents,
+      resources
+    };
+    await writable.write(JSON.stringify(cacheFile));
+    await writable.close();
+    this._channel.postMessage({
+      type: 'patch',
+      key: null,
+      resources: [...updatedResources.keys()]
+    });
+  }
+  async clear(reset) {
+    const fileHandle = await this._fileHandle;
+    const writable = await fileHandle.createWritable();
+    await writable.write('');
+    await writable.close();
+    this._invalidated = true;
+    this._lastModified = 0;
+    this._cache = null;
+    this._filePromise = null;
+    this._channel.postMessage({
+      type: 'clear'
+    });
+    if (!reset) {
+      this._channel.close();
+      this._channel = null;
+      if (!this.options.isolated) {
+        Storages.delete(this.options.scope);
+      }
+    }
+  }
+}
+function safeDocumentSerialize(document) {
+  const doc = document;
+  const newDoc = {};
+  if ('request' in doc) {
+    newDoc.request = prepareRequest(doc.request);
+  }
+  if ('response' in doc) {
+    newDoc.response = prepareResponse(doc.response);
+  }
+  if ('content' in doc) {
+    newDoc.content = structuredClone(doc.content);
+  }
+  return newDoc;
+}
+function prepareRequest(request) {
+  const {
+    signal,
+    headers
+  } = request;
+  const requestCopy = Object.assign({}, request);
+  delete requestCopy.store;
+  if (signal instanceof AbortSignal) {
+    delete requestCopy.signal;
+  }
+  if (headers instanceof Headers) {
+    requestCopy.headers = Array.from(headers);
+  }
+  return requestCopy;
+}
+function prepareResponse(response) {
+  if (!response) return null;
+  const clone = {};
+  if (response.headers) {
+    clone.headers = Array.from(response.headers);
+  }
+  clone.ok = response.ok;
+  clone.redirected = response.redirected;
+  clone.status = response.status;
+  clone.statusText = response.statusText;
+  clone.type = response.type;
+  clone.url = response.url;
+  return clone;
+}
+function safeDocumentHydrate(document) {
+  const doc = document;
+  const newDoc = {};
+  if ('request' in doc) {
+    const headers = new Headers(doc.request.headers);
+    const req = Object.assign({}, doc.request, {
+      headers
+    });
+    newDoc.request = new Request(doc.request.url ?? '', req);
+  }
+  if ('response' in doc) {
+    const headers = new Headers(doc.response.headers);
+    const resp = Object.assign({}, doc.response, {
+      headers
+    });
+    newDoc.response = new Response(null, resp);
+  }
+  if ('content' in doc) {
+    newDoc.content = structuredClone(doc.content);
+  }
+  return newDoc;
+}
+function docHasData(doc) {
+  return 'data' in doc;
+}
+const Storages = new Map();
+
+/**
+ * DocumentStorage is a wrapper around the StorageManager API that provides
+ * a simple interface for reading and updating documents and requests.
+ *
+ * Some goals for this experiment:
+ *
+ * - optimize for storing requests/documents
+ * - optimize for storing resources
+ * - optimize for looking up resources associated to a document
+ * - optimize for notifying cross-tab when data is updated
+ *
+ * optional features:
+ *
+ * - support for offline mode
+ * - ?? support for relationship based cache traversal
+ * - a way to index records by type + another field (e.g updatedAt/createAt/name)
+ *   such that simple queries can be done without having to scan all records
+ */
+class DocumentStorage {
+  constructor(options = {}) {
+    options.isolated = options.isolated ?? false;
+    options.scope = options.scope ?? 'default';
+    const fileName = `${WARP_DRIVE_STORAGE_FILE_NAME}@version_${WARP_DRIVE_STORAGE_VERSION}:${options.scope}`;
+    if (!options.isolated && Storages.has(fileName)) {
+      const storage = Storages.get(fileName);
+      if (storage) {
+        this._storage = storage.deref();
+        return;
+      }
+    }
+    const storage = new InternalDocumentStorage({
+      scope: fileName,
+      isolated: options.isolated
+    });
+    this._storage = storage;
+    if (!options.isolated) {
+      Storages.set(fileName, new WeakRef(storage));
+    }
+  }
+  getDocument(key) {
+    return this._storage.getDocument(key);
+  }
+  putDocument(document, resourceCollector) {
+    return this._storage.putDocument(document, resourceCollector);
+  }
+  putResources(document, resourceCollector) {
+    return this._storage.putResources(document, resourceCollector);
+  }
+  clear(reset) {
+    return this._storage.clear(reset);
+  }
+}
+
+export { DocumentStorage };

package/dist/unpkg/prod-deprecated/image-fetch.js

@@ -0,0 +1,74 @@
+import { createDeferred } from '@warp-drive/core/request';
+
+// @ts-expect-error untyped global
+const isServerEnv = typeof FastBoot !== 'undefined';
+class ImageFetch {
+  constructor(worker) {
+    this.threadId = isServerEnv ? '' : crypto.randomUUID();
+    this.pending = new Map();
+    this.cache = new Map();
+    this.worker = worker;
+    if (!isServerEnv) {
+      const fn = event => {
+        const {
+          type,
+          url
+        } = event.data;
+        const deferred = this.cleanupRequest(url);
+        if (!deferred) {
+          return;
+        }
+        if (type === 'success-response') {
+          deferred.resolve(url);
+          return;
+        }
+        if (type === 'error-response') {
+          deferred.reject(null);
+          return;
+        }
+      };
+      if (worker instanceof SharedWorker) {
+        worker.port.postMessage({
+          type: 'connect',
+          thread: this.threadId
+        });
+        worker.port.onmessage = fn;
+      } else if (worker) {
+        this.channel = new MessageChannel();
+        worker.postMessage({
+          type: 'connect',
+          thread: this.threadId
+        }, [this.channel.port2]);
+        this.channel.port1.onmessage = fn;
+      }
+    }
+  }
+  cleanupRequest(url) {
+    const deferred = this.pending.get(url);
+    this.pending.delete(url);
+    return deferred;
+  }
+  _send(event) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    this.worker instanceof SharedWorker ? this.worker.port.postMessage(event) : this.channel.port1.postMessage(event);
+  }
+  load(url) {
+    if (isServerEnv) {
+      return Promise.resolve(url);
+    }
+    const objectUrl = this.cache.get(url);
+    if (objectUrl) {
+      return Promise.resolve(objectUrl);
+    }
+    const deferred = createDeferred();
+    this.pending.set(url, deferred);
+    this._send({
+      type: 'load',
+      thread: this.threadId,
+      url
+    });
+    return deferred.promise;
+  }
+}
+
+export { ImageFetch };

package/dist/unpkg/prod-deprecated/image-worker.js

@@ -0,0 +1,99 @@
+const WorkerScope = globalThis.SharedWorkerGlobalScope;
+async function loadImage(url) {
+  const response = await fetch(url);
+  const fileBlob = await response.blob();
+  return URL.createObjectURL(fileBlob);
+}
+class ImageWorker {
+  constructor(options) {
+    // disable if running on main thread
+    if (typeof window !== 'undefined') {
+      return;
+    }
+    this.threads = new Map();
+    this.pendingImages = new Map();
+    this.cache = new Map();
+    this.options = options || {
+      persisted: false
+    };
+    this.isSharedWorker = WorkerScope && globalThis instanceof WorkerScope;
+    this.initialize();
+  }
+  fetch(url) {
+    const objectUrl = this.cache.get(url);
+    if (objectUrl) {
+      return Promise.resolve(objectUrl);
+    }
+    const pending = this.pendingImages.get(url);
+    if (pending) {
+      return pending;
+    }
+    const promise = loadImage(url);
+    this.pendingImages.set(url, promise);
+    return promise.finally(() => {
+      this.pendingImages.delete(url);
+    });
+  }
+  initialize() {
+    if (this.isSharedWorker) {
+      globalThis.onconnect = e => {
+        const port = e.ports[0];
+        port.onmessage = event => {
+          const {
+            type
+          } = event.data;
+          switch (type) {
+            case 'connect':
+              this.setupThread(event.data.thread, port);
+              break;
+          }
+        };
+        port.start();
+      };
+    } else {
+      globalThis.onmessage = event => {
+        const {
+          type
+        } = event.data;
+        switch (type) {
+          case 'connect':
+            this.setupThread(event.data.thread, event.ports[0]);
+            break;
+        }
+      };
+    }
+  }
+  setupThread(thread, port) {
+    this.threads.set(thread, port);
+    port.onmessage = event => {
+      if (event.type === 'close') {
+        this.threads.delete(thread);
+        return;
+      }
+      const {
+        type
+      } = event.data;
+      switch (type) {
+        case 'load':
+          void this.request(event.data);
+          break;
+      }
+    };
+  }
+  async request(event) {
+    const {
+      thread,
+      url
+    } = event;
+    const objectUrl = await this.fetch(url);
+    const port = this.threads.get(thread);
+    port.postMessage({
+      type: 'success-response',
+      thread,
+      url,
+      objectUrl
+    });
+  }
+}
+
+export { ImageWorker };

package/dist/unpkg/prod-deprecated/worker-fetch.js

@@ -0,0 +1,158 @@
+import { createDeferred } from '@warp-drive/core/request';
+
+// @ts-expect-error untyped global
+const isServerEnv = typeof FastBoot !== 'undefined';
+function isAggregateError(error) {
+  return error instanceof AggregateError || error.name === 'AggregateError' && Array.isArray(error.errors);
+}
+function stitchTrace(stack, origin) {
+  if (origin.startsWith('Error\n')) {
+    return origin.slice(6) + '\n' + stack;
+  }
+  return origin + '\n' + stack;
+}
+function cloneError(error, stack) {
+  const isAggregate = isAggregateError(error);
+  const cloned = isAggregate ? new AggregateError(structuredClone(error.errors), error.message) : new Error(error.message);
+  cloned.stack = stitchTrace(error.stack || '', stack);
+  cloned.error = error.error;
+
+  // copy over enumerable properties
+  Object.assign(cloned, error);
+  return cloned;
+}
+class WorkerFetch {
+  constructor(worker) {
+    this.threadId = isServerEnv ? '' : crypto.randomUUID();
+    this.pending = new Map();
+    this.worker = worker;
+    if (!isServerEnv) {
+      const fn = event => {
+        const {
+          type,
+          id,
+          data
+        } = event.data;
+        const info = this.cleanupRequest(id);
+
+        // typically this means the request was aborted
+        if (!info) {
+          return;
+        }
+        if (type === 'success-response') {
+          const {
+            deferred
+          } = info;
+          const {
+            response,
+            content
+          } = data;
+          if (response) {
+            response.headers = new Headers(response.headers);
+            info.context.setResponse(new Response(null, response));
+          }
+          deferred.resolve(content);
+          return;
+        }
+        if (type === 'error-response') {
+          const {
+            deferred,
+            stack
+          } = info;
+          deferred.reject(cloneError(data, stack));
+          return;
+        }
+      };
+      if (worker instanceof SharedWorker) {
+        worker.port.postMessage({
+          type: 'connect',
+          thread: this.threadId
+        });
+        worker.port.onmessage = fn;
+      } else if (worker) {
+        this.channel = new MessageChannel();
+        worker.postMessage({
+          type: 'connect',
+          thread: this.threadId
+        }, [this.channel.port2]);
+        this.channel.port1.onmessage = fn;
+      }
+    }
+  }
+  cleanupRequest(id) {
+    const info = this.pending.get(id);
+    this.pending.delete(id);
+    if (info?.signal) {
+      info.signal.removeEventListener('abort', info.abortFn);
+    }
+    return info;
+  }
+  send(event) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    this.worker instanceof SharedWorker ? this.worker.port.postMessage(event) : this.channel.port1.postMessage(event);
+  }
+  request(context, next) {
+    if (isServerEnv) {
+      return next(context.request);
+    }
+    const deferred = createDeferred();
+    const {
+      signal,
+      request
+    } = prepareRequest(context.request);
+    const abortFn = signal ? () => {
+      deferred.reject(enhanceReason(signal.reason));
+      this.send({
+        type: 'abort',
+        thread: this.threadId,
+        id: context.id,
+        data: signal.reason
+      });
+      this.cleanupRequest(context.id);
+    } : () => {
+      return;
+    };
+    signal?.addEventListener('abort', abortFn);
+    try {
+      throw new Error();
+    } catch (e) {
+      this.pending.set(context.id, {
+        context,
+        deferred,
+        signal,
+        abortFn,
+        stack: e.stack
+      });
+    }
+    this.send({
+      type: 'request',
+      thread: this.threadId,
+      id: context.id,
+      data: request
+    });
+    return deferred.promise;
+  }
+}
+function enhanceReason(reason) {
+  return new DOMException(reason || 'The user aborted a request.', 'AbortError');
+}
+function prepareRequest(request) {
+  const {
+    signal,
+    headers
+  } = request;
+  const requestCopy = Object.assign({}, request);
+  delete requestCopy.store;
+  if (signal instanceof AbortSignal) {
+    delete requestCopy.signal;
+  }
+  if (headers instanceof Headers) {
+    requestCopy.headers = Array.from(headers);
+  }
+  return {
+    signal: signal || null,
+    request: requestCopy
+  };
+}
+
+export { WorkerFetch };

package/logos/README.md

@@ -1,4 +1,4 @@
 # Autogeneration Notice
 
-This directory is maintained in the root of the monorepo and sync'd to public
-repositories by running `bun sync-logos`
+This directory is maintained in the root of the monorepo in `/logos/synced` and sync'd
+to public repositories by running `bun sync-logos`

package/logos/logo-yellow-slab.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1498" height="1047" fill="none" viewBox="0 0 1498 1047"><g filter="url(#a)"><path fill="url(#b)" d="M132 175.075C132 149.076 153.138 128 179.213 128H1318.23c26.08 0 47.22 21.076 47.22 47.075v688.85c0 25.999-21.14 47.075-47.22 47.075H179.213C153.138 911 132 889.924 132 863.925z"/><path fill="#201328" d="M1043.4 587.312c0-39.962 30.84-72.357 68.87-72.357h53.09c38.04 0 68.88-32.395 68.88-72.357v-92.651c0-39.962-30.84-72.358-68.88-72.358h-53.09c-38.01 0-68.82 32.351-68.87 72.275v92.734c0 39.962-30.83 72.357-68.869 72.357h-53.089c-38.036 0-68.871-32.395-68.871-72.357v-87.409c0-39.962-30.835-72.358-68.872-72.358h-51.654c-38.037 0-68.872 32.396-68.872 72.358v87.409c0 39.962-30.835 72.357-68.872 72.357h-53.088c-38.037 0-68.872-32.395-68.872-72.357v-92.652c0-39.961-30.835-72.357-68.872-72.357h-53.088c-38.037 0-68.872 32.396-68.872 72.357v92.652c0 39.962 30.835 72.357 68.872 72.357h53.088c38.037 0 68.872 32.395 68.872 72.357v101.741c0 39.962 30.835 72.358 68.872 72.358h53.088c38.037 0 68.872-32.396 68.872-72.358V587.312c0-39.962 30.835-72.357 68.872-72.357h51.654c38.037 0 68.872 32.395 68.872 72.357v101.741c0 39.962 30.835 72.358 68.871 72.358h53.089c38.039 0 68.869-32.396 68.869-72.358z"/></g><defs><linearGradient id="b" x1="748.724" x2="1167.5" y1="128" y2="1070.23" gradientUnits="userSpaceOnUse"><stop stop-color="#ffc474"/><stop offset="1" stop-color="#ff9809"/></linearGradient><filter id="a" width="1497.45" height="1047" x="0" y="0" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feColorMatrix in="SourceAlpha" result="hardAlpha" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0"/><feOffset dy="4"/><feGaussianBlur stdDeviation="66"/><feComposite in2="hardAlpha" operator="out"/><feColorMatrix values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.1 0"/><feBlend in2="BackgroundImageFix" result="effect1_dropShadow_757_188"/><feColorMatrix in="SourceAlpha" result="hardAlpha" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0"/><feOffset dy="4"/><feGaussianBlur stdDeviation="18"/><feComposite in2="hardAlpha" operator="out"/><feColorMatrix values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.25 0"/><feBlend in2="effect1_dropShadow_757_188" result="effect2_dropShadow_757_188"/><feColorMatrix in="SourceAlpha" result="hardAlpha" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0"/><feOffset dy="4"/><feGaussianBlur stdDeviation="2"/><feComposite in2="hardAlpha" operator="out"/><feColorMatrix values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.25 0"/><feBlend in2="effect2_dropShadow_757_188" result="effect3_dropShadow_757_188"/><feBlend in="SourceGraphic" in2="effect3_dropShadow_757_188" result="shape"/></filter></defs></svg>

package/logos/word-mark-black.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="2081" height="200" fill="none" viewBox="0 0 2081 200"><path fill="#000" d="M2064.89 185.359c-15.57 5.16-31.15 8.846-46.72 11.058q-23.22 3.456-47.55 3.456c-20.73 0-39.21-2.212-55.43-6.635q-24.18-6.773-40.77-19.49c-11.06-8.478-19.49-18.844-25.3-31.1-5.8-12.256-8.71-26.125-8.71-41.606 0-14.375 2.91-27.69 8.71-39.947 5.9-12.348 14.19-23.037 24.88-32.068 10.78-9.123 23.78-16.218 38.98-21.286C1928.19 2.58 1945.14 0 1963.85 0c17.23 0 32.99 2.35 47.27 7.05 14.38 4.607 26.68 11.472 36.91 20.595q15.48 13.684 23.91 33.727c5.71 13.361 8.57 28.75 8.57 46.167v12.716h-187.16a48.3 48.3 0 0 0 8.16 16.449c3.87 4.976 9.08 9.215 15.62 12.717 6.54 3.501 14.56 6.22 24.05 8.155 9.58 1.935 21.01 2.903 34.28 2.903 9.4 0 18.61-.553 27.64-1.659 9.04-1.198 17.47-2.719 25.3-4.562q11.745-2.902 21.15-6.358c6.36-2.304 11.47-4.607 15.34-6.911zm-35.38-102.7c-.47-4.7-1.89-9.538-4.29-14.514-2.3-5.069-5.99-9.63-11.06-13.685s-11.7-7.371-19.9-9.952q-12.3-4.008-30.69-4.008-17.28 0-29.85 4.285-12.585 4.284-21.15 10.643c-5.62 4.239-10 8.8-13.13 13.684-3.14 4.884-5.16 9.4-6.09 13.546zm-284.63 112.099h-59.71l-96.06-189.92h57.22l69.11 142.924 68.98-142.924h57.22zm-238.29 0V4.838h51.28v189.92zm-32.63-146.932c-1.38-.461-3.4-1.06-6.08-1.797q-3.87-1.245-9.12-2.35-5.25-1.244-11.61-2.073c-4.15-.553-8.43-.83-12.86-.83-9.21 0-17.83 1.152-25.84 3.456q-11.895 3.317-22.26 8.984a125.3 125.3 0 0 0-19.35 12.717c-5.9 4.7-11.33 9.537-16.31 14.514v114.311h-51.28V4.838h51.28v30.824c6.17-4.608 12.49-9.03 18.94-13.27a163 163 0 0 1 20.32-11.472c7.09-3.318 14.56-5.944 22.39-7.88 7.83-2.026 16.12-3.04 24.88-3.04 3.32 0 6.68.184 10.09.553 3.5.276 6.86.645 10.09 1.106 3.32.46 6.4.967 9.26 1.52s5.35 1.106 7.46 1.659zM1263.71 99.66c0 12.164-1.33 22.991-4 32.483-2.68 9.399-6.45 17.6-11.34 24.604-4.79 7.003-10.6 12.947-17.42 17.831q-10.08 7.325-22.53 11.749c-8.29 2.948-17.23 5.114-26.81 6.496q-14.37 1.935-30 1.935h-120.53V4.838h120.26c10.41 0 20.41.691 29.99 2.073 9.59 1.29 18.52 3.41 26.82 6.359 8.38 2.948 15.99 6.865 22.8 11.749 6.82 4.791 12.63 10.735 17.42 17.83 4.89 7.004 8.66 15.205 11.34 24.605 2.67 9.399 4 20.134 4 32.206m-51.69 0q0-13.685-3.6-23.775c-2.3-6.727-6.08-12.256-11.33-16.587-5.16-4.423-11.93-7.694-20.32-9.814-8.38-2.211-18.61-3.317-30.68-3.317h-63.73v107.262h63.73c12.07 0 22.3-1.06 30.68-3.179 8.39-2.212 15.16-5.529 20.32-9.952 5.25-4.515 9.03-10.137 11.33-16.864q3.6-10.09 3.6-23.774M986.574 63.169q0 14.237-4.699 25.157-4.562 10.92-14.514 18.383-9.952 7.464-25.71 11.335-15.62 3.732-37.735 3.732h-85.285v72.982h-17.278V4.838h102.563q22.116 0 37.735 3.87 15.758 3.732 25.71 11.058t14.514 18.246q4.7 10.92 4.699 25.157m-17.831 0q0-13.546-4.561-21.84-4.423-8.294-13.823-12.716-9.26-4.562-23.636-6.082-14.237-1.52-33.865-1.52h-74.227v84.593h74.227q7.602 0 16.172.138 8.709 0 17.14-.83 8.432-.967 16.034-3.179 7.74-2.349 13.546-7.05 5.945-4.699 9.399-12.301 3.594-7.602 3.594-19.213M766.455 19.49q-4.01-1.244-11.197-2.627-7.049-1.52-18.245-1.52-15.481 0-29.166 3.87-13.545 3.732-25.295 10.229a126.3 126.3 0 0 0-21.563 15.205q-9.951 8.57-17.969 18.245v131.866h-17.278V4.838h17.278V43.54a166 166 0 0 1 20.043-17.555q10.92-8.017 22.945-13.684a125.8 125.8 0 0 1 25.157-8.985Q724.435 0 738.533 0q4.839 0 8.708.276 3.87.14 7.05.553 3.317.277 6.22.691 2.902.416 5.944.968zm-220.33 175.268v-21.01q-9.952 5.39-22.669 9.952-12.579 4.562-26.677 7.879-13.96 3.318-28.751 5.114-14.79 1.797-29.027 1.797-18.522 0-33.312-3.317-14.652-3.318-24.881-9.814-10.228-6.635-15.757-16.31-5.529-9.814-5.529-22.669 0-12.717 6.358-22.393 6.497-9.813 18.384-17.001 11.887-7.326 28.612-12.302 16.864-5.115 37.598-8.57 20.733-3.594 44.784-5.806 24.19-2.349 50.867-3.87V61.925q0-8.846-3.318-15.62-3.317-6.772-9.261-11.749-5.943-5.115-13.96-8.431-8.017-3.456-17.416-5.53-9.262-2.074-19.628-2.902a219 219 0 0 0-20.596-.968q-13.96 0-25.433 1.383-11.473 1.381-21.425 3.87-9.952 2.35-19.075 5.529a563 563 0 0 0-18.384 6.773V14.099q19.213-5.114 40.915-8.846 21.839-3.87 46.305-3.87 20.733 0 38.703 3.593 17.969 3.456 31.238 11.196 13.27 7.74 20.872 20.043 7.603 12.164 7.603 29.718v128.825zm0-102.977q-45.2 2.489-77.268 7.05-31.929 4.561-52.248 11.196-20.32 6.634-29.857 15.481-9.399 8.846-9.399 20.042 0 9.123 4.561 16.173 4.7 7.049 13.408 11.887 8.708 4.7 21.148 7.188 12.44 2.349 27.922 2.349 9.123 0 18.798-.967a276 276 0 0 0 19.49-2.903 319 319 0 0 0 19.075-4.423q9.4-2.627 17.693-5.667t15.066-6.497q6.912-3.455 11.611-7.049zM180.245 4.838l67.73 176.098L318.193 4.838h19.213l-76.438 189.92h-25.71L168.634 23.222l-66.486 171.536h-25.71L0 4.838h19.213l70.218 176.098L157.023 4.838z"/></svg>