@amabeth/repeating-wheel-picker 1.0.0 → 1.2.0

package/example/node_modules/expo/src/errors/ExpoErrorManager.ts

@@ -0,0 +1,11 @@
+import type { ErrorHandlerCallback } from 'react-native';
+
+export function createErrorHandler(originalHandler: ErrorHandlerCallback): ErrorHandlerCallback {
+  return (error, isFatal) => originalHandler(error, isFatal);
+}
+
+/**
+ * @hidden
+ * @deprecated Will be removed in the future.
+ */
+export function disableErrorHandling() {}

package/example/node_modules/expo/src/hooks/useEvent.ts

@@ -0,0 +1,112 @@
+import type { EventEmitter } from 'expo-modules-core/types';
+import { useEffect, useRef, useState } from 'react';
+
+type AnyEventListener = (...args: any[]) => any;
+
+/**
+ * Type helper that infers the event name from the emitter's events map.
+ */
+type InferEventName<TEventsMap> =
+  TEventsMap extends Record<infer TEventName extends keyof TEventsMap, AnyEventListener>
+    ? TEventName
+    : never;
+
+/**
+ * Type helper that infers the event listener from the emitter's events map.
+ */
+type InferEventListener<TEventsMap, TEventName extends keyof TEventsMap> =
+  TEventsMap extends Record<TEventName, infer TEventListener extends AnyEventListener>
+    ? TEventListener
+    : never;
+
+/**
+ * Type helper that infers the first parameter of the event listener.
+ */
+type InferEventParameter<
+  TEventListener extends AnyEventListener,
+  TInitialValue,
+> = TInitialValue extends Parameters<TEventListener>[0]
+  ? Parameters<TEventListener>[0]
+  : Parameters<TEventListener>[0] | TInitialValue | null;
+
+/**
+ * React hook that listens to events emitted by the given object. The returned value is an event parameter
+ * that gets updated whenever a new event is dispatched.
+ * @param eventEmitter An object that emits events. For example, a native module or shared object or an instance of [`EventEmitter`](#eventemitter).
+ * @param eventName Name of the event to listen to.
+ * @param initialValue An event parameter to use until the event is called for the first time.
+ * @returns A parameter of the event listener.
+ * @example
+ * ```tsx
+ * import { useEvent } from 'expo';
+ * import { VideoPlayer } from 'expo-video';
+ *
+ * export function PlayerStatus({ videoPlayer }: { videoPlayer: VideoPlayer }) {
+ *   const { status } = useEvent(videoPlayer, 'statusChange', { status: videoPlayer.status });
+ *
+ *   return <Text>{`Player status: ${status}`}</Text>;
+ * }
+ * ```
+ */
+export function useEvent<
+  TEventsMap extends Record<string, AnyEventListener>,
+  TEventName extends InferEventName<TEventsMap>,
+  TEventListener extends InferEventListener<TEventsMap, TEventName>,
+  TInitialValue extends Parameters<TEventListener>[0] | null,
+>(
+  eventEmitter: EventEmitter<TEventsMap>,
+  eventName: TEventName,
+  initialValue: TInitialValue | null = null
+): InferEventParameter<TEventListener, TInitialValue> {
+  const [event, setEvent] = useState<Parameters<TEventListener>[0] | TInitialValue | null>(
+    initialValue
+  );
+  const listener = (event: Parameters<TEventListener>[0]) => setEvent(event);
+
+  useEventListener(eventEmitter, eventName, listener as InferEventListener<TEventsMap, TEventName>);
+
+  return event as InferEventParameter<TEventListener, TInitialValue>;
+}
+
+/**
+ * React hook that listens to events emitted by the given object and calls the listener function whenever a new event is dispatched.
+ * The event listener is automatically added during the first render and removed when the component unmounts.
+ * @param eventEmitter An object that emits events. For example, a native module or shared object or an instance of [`EventEmitter`](#eventemitter).
+ * @param eventName Name of the event to listen to.
+ * @param listener A function to call when the event is dispatched.
+ * @example
+ * ```tsx
+ * import { useEventListener } from 'expo';
+ * import { useVideoPlayer, VideoView } from 'expo-video';
+ *
+ * export function VideoPlayerView() {
+ *   const player = useVideoPlayer(videoSource);
+ *
+ *   useEventListener(player, 'playingChange', ({ isPlaying }) => {
+ *     console.log('Player is playing:', isPlaying);
+ *   });
+ *
+ *   return <VideoView player={player} />;
+ * }
+ * ```
+ */
+export function useEventListener<
+  TEventsMap extends Record<string, AnyEventListener>,
+  TEventName extends InferEventName<TEventsMap>,
+  TEventListener extends InferEventListener<TEventsMap, TEventName>,
+>(eventEmitter: EventEmitter<TEventsMap>, eventName: TEventName, listener: TEventListener): void {
+  // Always use the most recent version of the listener inside the effect,
+  // without memoization so the listeners don't have to be swapped with every render.
+  const listenerRef = useRef<TEventListener>(listener);
+  listenerRef.current = listener;
+
+  useEffect(() => {
+    const callback = (...args: any[]) => listenerRef.current(...args);
+    const subscription = eventEmitter.addListener<TEventName>(
+      eventName,
+      callback as TEventsMap[TEventName]
+    );
+
+    return () => subscription.remove();
+  }, [eventEmitter, eventName, listenerRef]);
+}

package/example/node_modules/expo/src/launch/registerRootComponent.tsx

@@ -0,0 +1,64 @@
+import '../Expo.fx';
+
+import { type ComponentType } from 'react';
+import { AppRegistry, Platform } from 'react-native';
+
+declare namespace globalThis {
+  // TODO(@kitten): What's the proper type here? What would AppRegistry need to accept?
+  const __EXPO_ROUTER_HYDRATE__: unknown;
+}
+
+type InitialProps = {
+  exp?: {
+    notification?: any;
+    manifestString?: string;
+    [key: string]: any;
+  };
+  shell?: boolean;
+  shellManifestUrl?: string;
+  [key: string]: any;
+};
+
+// @needsAudit
+/**
+ * Sets the initial React component to render natively in the app's root React Native view on Android, iOS, tvOS and the web.
+ *
+ * This method does the following:
+ * - Invokes React Native's `AppRegistry.registerComponent`.
+ * - Invokes React Native web's `AppRegistry.runApplication` on web to render to the root `index.html` file.
+ * - Polyfills the `process.nextTick` function globally.
+ *
+ * This method also adds the following dev-only features that are removed in production bundles.
+ * - Adds the Fast Refresh and bundle splitting indicator to the app.
+ * - Asserts if the `expo-updates` package is misconfigured.
+ * - Asserts if `react-native` is not aliased to `react-native-web` when running in the browser.
+ * @param component The React component class that renders the rest of your app.
+ * @see For information on how to setup `registerRootComponent` in an existing (bare) React Native app, see [Common questions](#rootregistercomponent-setup-for-existing-react-native-projects) below.
+ */
+export default function registerRootComponent<P extends InitialProps>(
+  component: ComponentType<P>
+): void {
+  let qualifiedComponent = component;
+
+  if (process.env.NODE_ENV !== 'production') {
+    const { withDevTools } = require('./withDevTools') as typeof import('./withDevTools');
+    qualifiedComponent = withDevTools(component);
+  }
+
+  AppRegistry.registerComponent('main', () => qualifiedComponent);
+  // Skip querying the DOM if we're in a Node.js environment.
+  if (Platform.OS === 'web' && typeof window !== 'undefined') {
+    const rootTag = document.getElementById('root');
+    if (process.env.NODE_ENV !== 'production') {
+      if (!rootTag) {
+        throw new Error('Required HTML element with id "root" was not found in the document HTML.');
+      }
+    }
+
+    AppRegistry.runApplication('main', {
+      rootTag,
+      // Injected by SSR HTML tags.
+      hydrate: globalThis.__EXPO_ROUTER_HYDRATE__,
+    });
+  }
+}

package/example/node_modules/expo/src/launch/withDevTools.ios.tsx

@@ -0,0 +1,47 @@
+import * as React from 'react';
+
+import DevLoadingView from '../environment/DevLoadingView';
+import { isRunningInExpoGo } from '../environment/ExpoGo';
+
+/**
+ * Append the Expo Fast Refresh view and optionally
+ * keep the screen awake if `expo-keep-awake` is installed.
+ */
+export function withDevTools<TComponent extends React.ComponentType<any>>(
+  AppRootComponent: TComponent
+): React.ComponentType<React.ComponentProps<TComponent>> {
+  // This hook can be optionally imported because __DEV__ never changes during runtime.
+  // Using __DEV__ like this enables tree shaking to remove the hook in production.
+  const useOptionalKeepAwake: (tag?: string) => void = (() => {
+    try {
+      // Optionally import expo-keep-awake
+      const { useKeepAwake, ExpoKeepAwakeTag } = require('expo-keep-awake');
+      return () => useKeepAwake(ExpoKeepAwakeTag, { suppressDeactivateWarnings: true });
+    } catch {}
+    return () => {};
+  })();
+
+  const shouldUseExpoFastRefreshView = isRunningInExpoGo();
+
+  function WithDevTools(props: React.ComponentProps<TComponent>) {
+    useOptionalKeepAwake();
+
+    if (shouldUseExpoFastRefreshView) {
+      return (
+        <>
+          <AppRootComponent {...props} />
+          <DevLoadingView />
+        </>
+      );
+    }
+
+    return <AppRootComponent {...props} />;
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    const name = AppRootComponent.displayName || AppRootComponent.name || 'Anonymous';
+    WithDevTools.displayName = `withDevTools(${name})`;
+  }
+
+  return WithDevTools;
+}

package/example/node_modules/expo/src/launch/withDevTools.tsx

@@ -0,0 +1,30 @@
+import * as React from 'react';
+
+// Keep the screen awake on Android, we don't use the Fast Refresh overlay here.
+// The default behavior here is to skip the custom Fast Refresh indicator.
+export function withDevTools<TComponent extends React.ComponentType<any>>(
+  AppRootComponent: TComponent
+): React.ComponentType<React.ComponentProps<TComponent>> {
+  // This hook can be optionally imported because __DEV__ never changes during runtime.
+  // Using __DEV__ like this enables tree shaking to remove the hook in production.
+  const useOptionalKeepAwake: (tag?: string) => void = (() => {
+    try {
+      // Optionally import expo-keep-awake
+      const { useKeepAwake, ExpoKeepAwakeTag } = require('expo-keep-awake');
+      return () => useKeepAwake(ExpoKeepAwakeTag, { suppressDeactivateWarnings: true });
+    } catch {}
+    return () => {};
+  })();
+
+  function WithDevTools(props: React.ComponentProps<TComponent>) {
+    useOptionalKeepAwake();
+    return <AppRootComponent {...props} />;
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    const name = AppRootComponent.displayName || AppRootComponent.name || 'Anonymous';
+    WithDevTools.displayName = `withDevTools(${name})`;
+  }
+
+  return WithDevTools;
+}

package/example/node_modules/expo/src/launch/withDevTools.web.tsx

@@ -0,0 +1,23 @@
+import * as React from 'react';
+
+import DevLoadingView from '../environment/DevLoadingView';
+
+export function withDevTools<TComponent extends React.ComponentType<any>>(
+  AppRootComponent: TComponent
+): React.ComponentType<React.ComponentProps<TComponent>> {
+  function WithDevTools(props: React.ComponentProps<TComponent>) {
+    return (
+      <>
+        <AppRootComponent {...props} />
+        <DevLoadingView />
+      </>
+    );
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    const name = AppRootComponent.displayName || AppRootComponent.name || 'Anonymous';
+    WithDevTools.displayName = `withDevTools(${name})`;
+  }
+
+  return WithDevTools;
+}

package/example/node_modules/expo/src/timer/polyfillNextTick.ts

@@ -0,0 +1,10 @@
+/**
+ * Defines a small polyfill for process.nextTick. Eventually we'd like to replace this polyfill with
+ * a native implementation with the correct timing semantics.
+ */
+
+if (!process.nextTick) {
+  process.nextTick = (callback: (...args: any[]) => any, ...args: any[]) => {
+    setTimeout(() => callback(...args), 0);
+  };
+}

package/example/node_modules/expo/src/ts-declarations/console.d.ts

@@ -0,0 +1,47 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved. 
+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  
+ 
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
+MERCHANTABLITY OR NON-INFRINGEMENT. 
+ 
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+/**
+ * This is a more comprehensive declaration of the Console API that JavaScript VMs include.
+ *
+ * This declaration is from https://github.com/Microsoft/TypeScript/blob/master/lib/lib.dom.d.ts
+ */
+interface Console {
+  memory: any;
+  assert(condition?: boolean, message?: string, ...data: any[]): void;
+  clear(): void;
+  count(label?: string): void;
+  debug(message?: any, ...optionalParams: any[]): void;
+  dir(value?: any, ...optionalParams: any[]): void;
+  dirxml(value: any): void;
+  error(message?: any, ...optionalParams: any[]): void;
+  exception(message?: string, ...optionalParams: any[]): void;
+  group(groupTitle?: string, ...optionalParams: any[]): void;
+  groupCollapsed(groupTitle?: string, ...optionalParams: any[]): void;
+  groupEnd(): void;
+  info(message?: any, ...optionalParams: any[]): void;
+  log(message?: any, ...optionalParams: any[]): void;
+  markTimeline(label?: string): void;
+  profile(reportName?: string): void;
+  profileEnd(reportName?: string): void;
+  table(...tabularData: any[]): void;
+  time(label?: string): void;
+  timeEnd(label?: string): void;
+  timeStamp(label?: string): void;
+  timeline(label?: string): void;
+  timelineEnd(label?: string): void;
+  trace(message?: any, ...optionalParams: any[]): void;
+  warn(message?: any, ...optionalParams: any[]): void;
+}

package/example/node_modules/expo/src/ts-declarations/global.d.ts

@@ -0,0 +1,12 @@
+declare const global: any;
+
+declare global {
+  // Augment global type for FormData prototype to include missing methods: keys, values, entries, and Symbol.iterator
+  // These methods are used in React for server actions.
+  interface FormData {
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string | Blob>;
+    entries(): IterableIterator<[string, string | Blob]>;
+    [Symbol.iterator](): IterableIterator<[string, string | Blob]>;
+  }
+}

package/example/node_modules/expo/src/ts-declarations/react-native.d.ts

@@ -0,0 +1,34 @@
+declare module 'react-native/Libraries/NativeModules/specs/NativeSourceCode' {
+  namespace SourceCode {
+    function getConstants(): { scriptURL: string };
+  }
+  export default SourceCode;
+}
+
+declare module 'react-native/Libraries/Network/FormData' {
+  type FormDataValue = string | { name?: string; type?: string; uri: string };
+
+  type Headers = {
+    [name: string]: string;
+  };
+
+  type FormDataPart =
+    | {
+        string: string;
+        headers: Headers;
+      }
+    | {
+        uri: string;
+        headers: Headers;
+        name?: string;
+        type?: string;
+      };
+
+  class FormData {
+    append(key: string, value: FormDataValue): void;
+    getAll(key: string): FormDataValue[];
+    getParts(): FormDataPart[];
+  }
+
+  export default FormData;
+}

package/example/node_modules/expo/src/ts-declarations/whatwg-url-without-unicode.d.ts

@@ -0,0 +1,186 @@
+// NOTE(@kitten): This is based on @types/whatwg-url
+declare module 'whatwg-url-without-unicode' {
+  /// <reference lib="es2020"/>
+  /** https://url.spec.whatwg.org/#url-representation */
+  export interface URLRecord {
+    scheme: string;
+    username: string;
+    password: string;
+    host: string | number | IPv6Address | null;
+    port: number | null;
+    path: string | string[];
+    query: string | null;
+    fragment: string | null;
+  }
+
+  /** https://url.spec.whatwg.org/#concept-ipv6 */
+  export type IPv6Address = [number, number, number, number, number, number, number, number];
+
+  // NOTE(@kitten): This is a custom modification to add static methods with an overlay
+  // We should make this available to users in expo/types, which should be linked to our own Winter implementation,
+  // and compatible with built-ins. Until then, we're adding this so we can polyfill properly in `src/winter/url.ts`
+  export const URL: URLConstructor;
+  export interface URLConstructor {
+    new (url: string, base?: string | URL): URL;
+    (url: string, base?: string | URL): URL;
+    canParse(url: string, base?: string): boolean;
+  }
+
+  /** https://url.spec.whatwg.org/#url-class */
+  interface URL {
+    constructor(url: string, base?: string | URL);
+
+    get href(): string;
+    set href(V: string);
+
+    get origin(): string;
+
+    get protocol(): string;
+    set protocol(V: string);
+
+    get username(): string;
+    set username(V: string);
+
+    get password(): string;
+    set password(V: string);
+
+    get host(): string;
+    set host(V: string);
+
+    get hostname(): string;
+    set hostname(V: string);
+
+    get port(): string;
+    set port(V: string);
+
+    get pathname(): string;
+    set pathname(V: string);
+
+    get search(): string;
+    set search(V: string);
+
+    get searchParams(): URLSearchParams;
+
+    get hash(): string;
+    set hash(V: string);
+
+    toJSON(): string;
+
+    readonly [Symbol.toStringTag]: 'URL';
+  }
+
+  /** https://url.spec.whatwg.org/#interface-urlsearchparams */
+  export class URLSearchParams {
+    constructor(
+      init?:
+        | readonly (readonly [name: string, value: string])[]
+        | Iterable<readonly [name: string, value: string]>
+        | { readonly [name: string]: string }
+        | string
+    );
+
+    get size(): number;
+    append(name: string, value: string): void;
+    delete(name: string, value?: string): void;
+    get(name: string): string | null;
+    getAll(name: string): string[];
+    has(name: string, value?: string): boolean;
+    set(name: string, value: string): void;
+    sort(): void;
+
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+    entries(): IterableIterator<[name: string, value: string]>;
+    forEach<THIS_ARG = void>(
+      callback: (this: THIS_ARG, value: string, name: string, searchParams: this) => void,
+      thisArg?: THIS_ARG
+    ): void;
+
+    readonly [Symbol.toStringTag]: 'URLSearchParams';
+    [Symbol.iterator](): IterableIterator<[name: string, value: string]>;
+  }
+
+  /** https://url.spec.whatwg.org/#concept-url-parser */
+  export function parseURL(
+    input: string,
+    options?: { readonly baseURL?: URLRecord | undefined }
+  ): URLRecord | null;
+
+  /** https://url.spec.whatwg.org/#concept-basic-url-parser */
+  export function basicURLParse(
+    input: string,
+    options?: {
+      baseURL?: URLRecord | undefined;
+      url?: URLRecord | undefined;
+      stateOverride?: StateOverride | undefined;
+    }
+  ): URLRecord | null;
+
+  /** https://url.spec.whatwg.org/#scheme-start-state */
+  export type StateOverride =
+    | 'scheme start'
+    | 'scheme'
+    | 'no scheme'
+    | 'special relative or authority'
+    | 'path or authority'
+    | 'relative'
+    | 'relative slash'
+    | 'special authority slashes'
+    | 'special authority ignore slashes'
+    | 'authority'
+    | 'host'
+    | 'hostname'
+    | 'port'
+    | 'file'
+    | 'file slash'
+    | 'file host'
+    | 'path start'
+    | 'path'
+    | 'opaque path'
+    | 'query'
+    | 'fragment';
+
+  /** https://url.spec.whatwg.org/#concept-url-serializer */
+  export function serializeURL(urlRecord: URLRecord, excludeFragment?: boolean): string;
+
+  /** https://url.spec.whatwg.org/#concept-host-serializer */
+  export function serializeHost(host: string | number | IPv6Address): string;
+
+  /** https://url.spec.whatwg.org/#url-path-serializer */
+  export function serializePath(urlRecord: URLRecord): string;
+
+  /** https://url.spec.whatwg.org/#serialize-an-integer */
+  export function serializeInteger(number: number): string;
+
+  /** https://html.spec.whatwg.org#ascii-serialisation-of-an-origin */
+  export function serializeURLOrigin(urlRecord: URLRecord): string;
+
+  /** https://url.spec.whatwg.org/#set-the-username */
+  export function setTheUsername(urlRecord: URLRecord, username: string): void;
+
+  /** https://url.spec.whatwg.org/#set-the-password */
+  export function setThePassword(urlRecord: URLRecord, password: string): void;
+
+  /** https://url.spec.whatwg.org/#url-opaque-path */
+  export function hasAnOpaquePath(urlRecord: URLRecord): boolean;
+
+  /** https://url.spec.whatwg.org/#cannot-have-a-username-password-port */
+  export function cannotHaveAUsernamePasswordPort(urlRecord: URLRecord): boolean;
+
+  /** https://url.spec.whatwg.org/#percent-decode */
+  export function percentDecodeBytes(buffer: TypedArray): Uint8Array;
+
+  /** https://url.spec.whatwg.org/#string-percent-decode */
+  export function percentDecodeString(string: string): Uint8Array;
+
+  export type TypedArray =
+    | Uint8Array
+    | Uint8ClampedArray
+    | Uint16Array
+    | Uint32Array
+    | Int8Array
+    | Int16Array
+    | Int32Array
+    | Float32Array
+    | Float64Array;
+}

package/example/node_modules/expo/src/utils/blobUtils.ts

@@ -0,0 +1,23 @@
+/**
+ * Converts a Blob to an ArrayBuffer.
+ */
+export function blobToArrayBufferAsync(blob: Blob): Promise<ArrayBuffer> {
+  if (typeof blob.arrayBuffer === 'function') {
+    return blob.arrayBuffer();
+  }
+  return legacyBlobToArrayBufferAsync(blob);
+}
+
+/**
+ * Converts a Blob to an ArrayBuffer using the FileReader API.
+ */
+export async function legacyBlobToArrayBufferAsync(blob: Blob): Promise<ArrayBuffer> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      resolve(reader.result as ArrayBuffer);
+    };
+    reader.onerror = reject;
+    reader.readAsArrayBuffer(blob);
+  });
+}

package/example/node_modules/expo/src/utils/getBundleUrl.native.ts

@@ -0,0 +1,17 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+/// <reference path="../ts-declarations/react-native.d.ts" />
+
+import SourceCode from 'react-native/Libraries/NativeModules/specs/NativeSourceCode';
+
+export function getBundleUrl(): string | null {
+  let scriptURL = SourceCode.getConstants().scriptURL;
+  if (scriptURL == null) {
+    return null;
+  }
+  if (scriptURL.startsWith('/')) {
+    scriptURL = `file://${scriptURL}`;
+  }
+  const url = new URL(scriptURL);
+  return url.toString();
+}

package/example/node_modules/expo/src/utils/getBundleUrl.ts

@@ -0,0 +1,5 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+export function getBundleUrl(): string | null {
+  return null;
+}

package/example/node_modules/expo/src/utils/getBundleUrl.web.ts

@@ -0,0 +1,21 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+export function getBundleUrl(): string | null {
+  let scriptURL: string | null | undefined = null;
+
+  if (typeof window === 'undefined') {
+    // For server runtime, we use the filename of the current script
+    // @ts-ignore The react-native tsconfig doesn't support CJS
+    scriptURL = 'file://' + __filename;
+  } else {
+    // TODO: Try to support `import.meta.url` when the ecosystem supports ESM,
+    // and jest doesn't throw SyntaxError when accessing `import.meta`.
+    scriptURL = (document.currentScript as HTMLScriptElement)?.src;
+  }
+
+  if (scriptURL == null) {
+    return null;
+  }
+  const url = new URL(scriptURL);
+  return `${url.protocol}//${url.host}${url.pathname}`;
+}