@tuturuuu/ui 0.19.0 → 0.20.1

package/src/globals.css

@@ -442,6 +442,172 @@
   --animate-accordion-up: accordion-up 0.2s ease-out;
   --animate-aurora: aurora 80s linear infinite;
   --animate-shake: shake 0.5s cubic-bezier(0.36, 0.07, 0.19, 0.97) both;
+  --animate-bloom-drift: bloom-drift 24s ease-in-out infinite;
+  --animate-bloom-drift-slow: bloom-drift-slow 32s ease-in-out infinite;
+  --animate-sheen: sheen 6s ease-in-out infinite;
+  --animate-rise-in: rise-in 0.9s cubic-bezier(0.16, 1, 0.3, 1) both;
+  --animate-text-sheen: text-sheen 8s ease-in-out infinite;
+  --animate-marquee: marquee 40s linear infinite;
+  --animate-float-y: float-y 6s ease-in-out infinite;
+  --animate-scroll-cue: scroll-cue 2.2s ease-in-out infinite;
+  --animate-ring-pulse: ring-pulse 3s ease-out infinite;
+  --animate-day-scan: day-scan 9s ease-in-out infinite;
+
+  /* Marketing type scale. The variables resolve only where the marketing
+     layout loads the fonts; everywhere else these fall back to the app font. */
+  /* The inner fallbacks matter: apps that do not load the marketing faces
+     (nova, meet) would otherwise hit an undefined var and drop the whole
+     font-family declaration. */
+  --font-display:
+    var(--font-be-vietnam-pro, ui-sans-serif), ui-sans-serif, system-ui,
+    sans-serif;
+  --font-mono-ui:
+    var(--font-jetbrains-mono, ui-monospace), ui-monospace, SFMono-Regular,
+    Menlo, monospace;
+}
+
+/* Marketing atmosphere: slow, low-amplitude drift for hero light blooms. */
+@keyframes bloom-drift {
+  0%,
+  100% {
+    transform: translate3d(0, 0, 0) scale(1);
+  }
+  50% {
+    transform: translate3d(4%, -3%, 0) scale(1.08);
+  }
+}
+
+@keyframes bloom-drift-slow {
+  0%,
+  100% {
+    transform: translate3d(0, 0, 0) scale(1.05);
+  }
+  50% {
+    transform: translate3d(-5%, 4%, 0) scale(1);
+  }
+}
+
+@keyframes sheen {
+  0%,
+  100% {
+    opacity: 0.35;
+  }
+  50% {
+    opacity: 0.75;
+  }
+}
+
+/* Hero entrance. Paired with an inline animation-delay for stagger, so the
+   choreography needs no JavaScript and runs before hydration. */
+@keyframes rise-in {
+  from {
+    opacity: 0;
+    transform: translate3d(0, 24px, 0);
+    filter: blur(12px);
+  }
+  to {
+    opacity: 1;
+    transform: translate3d(0, 0, 0);
+    filter: blur(0);
+  }
+}
+
+/* Slow light travelling through gradient headline text. */
+@keyframes text-sheen {
+  0%,
+  100% {
+    background-position: 0% 50%;
+  }
+  50% {
+    background-position: 100% 50%;
+  }
+}
+
+/* Product marquee: the track holds two identical halves, so -50% loops
+   seamlessly. */
+@keyframes marquee {
+  from {
+    transform: translate3d(0, 0, 0);
+  }
+  to {
+    transform: translate3d(-50%, 0, 0);
+  }
+}
+
+@keyframes float-y {
+  0%,
+  100% {
+    transform: translate3d(0, 0, 0);
+  }
+  50% {
+    transform: translate3d(0, -10px, 0);
+  }
+}
+
+@keyframes scroll-cue {
+  0% {
+    opacity: 0;
+    transform: translate3d(0, -6px, 0);
+  }
+  40% {
+    opacity: 1;
+  }
+  100% {
+    opacity: 0;
+    transform: translate3d(0, 10px, 0);
+  }
+}
+
+/* Restless light crossing the fragmented day on the landing page. Driving
+   background-position (rather than a transform) keeps the highlight clipped to
+   the strip, so it never has to be masked. Symmetric endpoints let it sweep
+   out and back on one eased loop with no seam. */
+@keyframes day-scan {
+  0%,
+  100% {
+    background-position: 130% 0;
+  }
+  50% {
+    background-position: -30% 0;
+  }
+}
+
+@keyframes ring-pulse {
+  0% {
+    opacity: 0.6;
+    transform: scale(0.85);
+  }
+  100% {
+    opacity: 0;
+    transform: scale(1.6);
+  }
+}
+
+/* Global guard: the marketing atmosphere and entrance choreography are
+   decorative, so drop them entirely when the user asks for less motion. */
+@media (prefers-reduced-motion: reduce) {
+  .animate-rise-in,
+  .animate-text-sheen,
+  .animate-marquee,
+  .animate-float-y,
+  .animate-scroll-cue,
+  .animate-ring-pulse,
+  .animate-day-scan,
+  .animate-bloom-drift,
+  .animate-bloom-drift-slow,
+  .animate-sheen,
+  .animate-aurora {
+    /*
+     * Cancelling the animation is enough, and is all we should do. These
+     * elements carry layout transforms (`-translate-x-1/2` centres the hero
+     * blooms) and deliberate opacities (blooms sit at 40-60%), so forcing
+     * `transform: none` / `opacity: 1` here would shift them off-centre and
+     * blow out their brightness. Entrance keyframes use `both`, so removing
+     * the animation simply leaves the element in its natural, final state.
+     */
+    /* biome-ignore lint/complexity/noImportantStyles: must beat utility-class animations for accessibility */
+    animation: none !important;
+  }
 }
 
 /* Aurora animation - must be outside @theme block */

package/src/hooks/__tests__/use-workspace-identity-mutation.test.tsx

@@ -0,0 +1,181 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import type { ReactNode } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  patchWorkspaceCacheValue,
+  useUpdateWorkspaceIdentity,
+} from '../use-workspace-identity-mutation';
+
+const WS_ID = 'ws-1';
+
+const mocks = vi.hoisted(() => ({
+  refresh: vi.fn(),
+  updateWorkspace: vi.fn(),
+}));
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => ({ refresh: mocks.refresh }),
+}));
+
+vi.mock('@tuturuuu/internal-api/workspaces', () => ({
+  updateWorkspace: (...args: unknown[]) => mocks.updateWorkspace(...args),
+}));
+
+function createHarness() {
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+
+  // The surfaces that show a workspace name, as each one caches it.
+  queryClient.setQueryData(
+    ['workspaces'],
+    [
+      { id: WS_ID, name: 'Old name' },
+      { id: 'ws-2', name: 'Other workspace' },
+    ]
+  );
+  queryClient.setQueryData(['workspace', WS_ID], {
+    workspace: { handle: 'old-handle', id: WS_ID, name: 'Old name' },
+  });
+  queryClient.setQueryData(['workspace-select-current-workspace', WS_ID], {
+    id: WS_ID,
+    name: 'Old name',
+  });
+  queryClient.setQueryData(['unrelated'], { id: WS_ID, name: 'Old name' });
+
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  );
+
+  return { queryClient, wrapper };
+}
+
+describe('patchWorkspaceCacheValue', () => {
+  it('patches the record, arrays of records, and wrapped shapes', () => {
+    const patch = { name: 'New name' };
+
+    expect(
+      patchWorkspaceCacheValue({ id: WS_ID, name: 'Old' }, WS_ID, patch)
+    ).toEqual({ id: WS_ID, name: 'New name' });
+
+    expect(
+      patchWorkspaceCacheValue([{ id: WS_ID, name: 'Old' }], WS_ID, patch)
+    ).toEqual([{ id: WS_ID, name: 'New name' }]);
+
+    expect(
+      patchWorkspaceCacheValue(
+        { workspace: { id: WS_ID, name: 'Old' } },
+        WS_ID,
+        patch
+      )
+    ).toEqual({ workspace: { id: WS_ID, name: 'New name' } });
+  });
+
+  it('leaves other workspaces and unknown shapes alone', () => {
+    const other = { id: 'ws-2', name: 'Other' };
+    expect(patchWorkspaceCacheValue(other, WS_ID, { name: 'New' })).toBe(other);
+    expect(patchWorkspaceCacheValue(null, WS_ID, { name: 'New' })).toBeNull();
+    expect(patchWorkspaceCacheValue('text', WS_ID, { name: 'New' })).toBe(
+      'text'
+    );
+  });
+});
+
+describe('useUpdateWorkspaceIdentity', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.updateWorkspace.mockResolvedValue({ id: WS_ID });
+  });
+
+  // Regression: renaming a workspace used to only call `router.refresh()`, which
+  // re-renders server markup but leaves client caches untouched — so the
+  // workspace selector kept the old name until the user reloaded the page.
+  it('renames the workspace everywhere it is cached', async () => {
+    const { queryClient, wrapper } = createHarness();
+    const { result } = renderHook(
+      () => useUpdateWorkspaceIdentity({ workspaceId: WS_ID }),
+      { wrapper }
+    );
+
+    await act(async () => {
+      await result.current.mutateAsync({ name: 'New name' });
+    });
+
+    expect(queryClient.getQueryData(['workspaces'])).toEqual([
+      { id: WS_ID, name: 'New name' },
+      { id: 'ws-2', name: 'Other workspace' },
+    ]);
+    expect(queryClient.getQueryData(['workspace', WS_ID])).toEqual({
+      workspace: { handle: 'old-handle', id: WS_ID, name: 'New name' },
+    });
+    expect(
+      queryClient.getQueryData(['workspace-select-current-workspace', WS_ID])
+    ).toEqual({ id: WS_ID, name: 'New name' });
+  });
+
+  it('refreshes server-rendered surfaces too', async () => {
+    const { wrapper } = createHarness();
+    const { result } = renderHook(
+      () => useUpdateWorkspaceIdentity({ workspaceId: WS_ID }),
+      { wrapper }
+    );
+
+    await act(async () => {
+      await result.current.mutateAsync({ name: 'New name' });
+    });
+
+    await waitFor(() => expect(mocks.refresh).toHaveBeenCalledTimes(1));
+  });
+
+  it('updates the cache before the request resolves', async () => {
+    const { queryClient, wrapper } = createHarness();
+    let resolveUpdate: (value: unknown) => void = () => {};
+    mocks.updateWorkspace.mockReturnValue(
+      new Promise((resolve) => {
+        resolveUpdate = resolve;
+      })
+    );
+
+    const { result } = renderHook(
+      () => useUpdateWorkspaceIdentity({ workspaceId: WS_ID }),
+      { wrapper }
+    );
+
+    await act(async () => {
+      void result.current.mutateAsync({ name: 'Optimistic name' });
+      await Promise.resolve();
+    });
+
+    expect(queryClient.getQueryData(['workspaces'])).toEqual([
+      { id: WS_ID, name: 'Optimistic name' },
+      { id: 'ws-2', name: 'Other workspace' },
+    ]);
+
+    await act(async () => {
+      resolveUpdate({ id: WS_ID });
+    });
+  });
+
+  it('rolls the caches back when the rename fails', async () => {
+    const { queryClient, wrapper } = createHarness();
+    const onError = vi.fn();
+    mocks.updateWorkspace.mockRejectedValue(new Error('nope'));
+
+    const { result } = renderHook(
+      () => useUpdateWorkspaceIdentity({ onError, workspaceId: WS_ID }),
+      { wrapper }
+    );
+
+    await act(async () => {
+      await result.current.mutateAsync({ name: 'New name' }).catch(() => {});
+    });
+
+    expect(queryClient.getQueryData(['workspaces'])).toEqual([
+      { id: WS_ID, name: 'Old name' },
+      { id: 'ws-2', name: 'Other workspace' },
+    ]);
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(mocks.refresh).not.toHaveBeenCalled();
+  });
+});

package/src/hooks/use-workspace-identity-mutation.ts

@@ -0,0 +1,136 @@
+'use client';
+
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { updateWorkspace } from '@tuturuuu/internal-api/workspaces';
+import { useRouter } from 'next/navigation';
+
+export interface WorkspaceIdentityPatch {
+  handle?: string;
+  name?: string;
+}
+
+interface QueryKeyFilter {
+  queryKey: readonly unknown[];
+}
+
+/**
+ * Matches every cached query that can carry this workspace's name or handle.
+ *
+ * The workspace selector reads `['workspaces']`, satellite panels read
+ * `['workspace', wsId]`, and the selector's fallback reads
+ * `['workspace-select-current-workspace', wsId]` — so match by the well-known
+ * roots plus any key mentioning the workspace id.
+ */
+export function createWorkspaceQueryFilter(workspaceId: string) {
+  return {
+    predicate: ({ queryKey }: QueryKeyFilter) =>
+      queryKey[0] === 'workspaces' ||
+      queryKey[0] === 'user-workspaces' ||
+      queryKey.includes(workspaceId),
+  };
+}
+
+/**
+ * Apply a patch to any shape a workspace can take inside a cached value: the
+ * record itself, an array of records, or a wrapper such as `{ data }`,
+ * `{ workspace }` or `{ workspaces }`.
+ */
+export function patchWorkspaceCacheValue(
+  value: unknown,
+  workspaceId: string,
+  patch: WorkspaceIdentityPatch
+): unknown {
+  if (Array.isArray(value)) {
+    let changed = false;
+    const nextArray = value.map((entry) => {
+      const nextEntry = patchWorkspaceCacheValue(entry, workspaceId, patch);
+      if (nextEntry !== entry) changed = true;
+      return nextEntry;
+    });
+
+    return changed ? nextArray : value;
+  }
+
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+
+  const record = value as Record<string, unknown>;
+  if (record.id === workspaceId) {
+    return { ...record, ...patch };
+  }
+
+  let changed = false;
+  const nextRecord = { ...record };
+  for (const key of ['data', 'workspace', 'workspaces'] as const) {
+    if (!(key in record)) continue;
+    const nextValue = patchWorkspaceCacheValue(record[key], workspaceId, patch);
+    if (nextValue !== record[key]) {
+      nextRecord[key] = nextValue;
+      changed = true;
+    }
+  }
+
+  return changed ? nextRecord : value;
+}
+
+/**
+ * Rename a workspace and make every surface agree, without a page reload.
+ *
+ * A workspace name is read from two independent places: client caches (the
+ * workspace selector, settings panels) and server-rendered markup (sidebars,
+ * headers). `router.refresh()` only refreshes the second, so a form that just
+ * calls it leaves the selector showing the old name until the user reloads —
+ * which is exactly what shipped in `apps/web`. This does all three steps:
+ * patch the caches optimistically, revalidate them, and refresh the server tree.
+ *
+ * Every app's settings dialog should mutate the workspace through this hook, so
+ * the propagation rules live in one place rather than being re-derived per app.
+ */
+export function useUpdateWorkspaceIdentity({
+  onError,
+  onSuccess,
+  workspaceId,
+}: {
+  onError?: (error: unknown) => void;
+  onSuccess?: (patch: WorkspaceIdentityPatch) => void;
+  workspaceId: string;
+}) {
+  const queryClient = useQueryClient();
+  const router = useRouter();
+  const workspaceQueryFilter = createWorkspaceQueryFilter(workspaceId);
+
+  return useMutation({
+    mutationFn: (values: WorkspaceIdentityPatch) =>
+      updateWorkspace(workspaceId, values as { handle?: string; name: string }),
+    onError: (error, _values, context) => {
+      for (const [queryKey, previous] of context?.previousQueries ?? []) {
+        queryClient.setQueryData(queryKey, previous);
+      }
+
+      onError?.(error);
+    },
+    onMutate: async (values: WorkspaceIdentityPatch) => {
+      await queryClient.cancelQueries(workspaceQueryFilter);
+      const previousQueries = queryClient.getQueriesData(workspaceQueryFilter);
+
+      queryClient.setQueriesData(workspaceQueryFilter, (previous) =>
+        patchWorkspaceCacheValue(previous, workspaceId, values)
+      );
+
+      return { previousQueries };
+    },
+    onSuccess: async (_response, values: WorkspaceIdentityPatch) => {
+      queryClient.setQueriesData(workspaceQueryFilter, (previous) =>
+        patchWorkspaceCacheValue(previous, workspaceId, values)
+      );
+
+      await queryClient.invalidateQueries(workspaceQueryFilter);
+      // Server-rendered surfaces (sidebar header, page titles) need this; the
+      // cache work above is what keeps the client-side selector honest.
+      router.refresh();
+
+      onSuccess?.(values);
+    },
+  });
+}

package/vendor/xlsx/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (C) 2012-present   SheetJS LLC
+
+   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.