@occluze/tether 0.6.8 → 0.7.0

package/src/lazy-iife.js

@@ -1,116 +0,0 @@
-/**
- * `<script>` build: the optional parts are separate files next to tether(.min).js (tether.markets.min.js), loaded on
- * first use. `partsUrl` sets another folder. A part registers itself in `window.Tether.__parts` and uses the core
- * modules in `window.Tether.__core` instead of bundling copies of them.
- */
-import * as config from './config.js';
-import * as client from './client.js';
-import * as dom from './dom.js';
-import * as fragments from './fragments.js';
-import * as loader from './loader.js';
-import * as sellingPlans from './selling-plans.js';
-import * as status from './status.js';
-import * as cart from './cart.js';
-import * as product from './product.js';
-import * as collection from './collection.js';
-import * as mounting from './mounting.js';
-import * as marketCodes from './market-codes.js';
-import * as shopifyValues from './shopify-values.js';
-import * as storeHtml from './store-html.js';
-/** @import { Parts, PartName } from './lazy.js' */
-
-const { cfg } = config;
-
-/**
- * The modules a part may use, shared instead of bundled twice (scripts/build.mjs maps a part's imports to these).
- *
- * @type {Record<string, object>}
- */
-export const coreModules = {
-  'config.js': config,
-  'client.js': client,
-  'dom.js': dom,
-  'fragments.js': fragments,
-  'loader.js': loader,
-  'selling-plans.js': sellingPlans,
-  'status.js': status,
-  'cart.js': cart,
-  'product.js': product,
-  'collection.js': collection,
-  'mounting.js': mounting,
-  'market-codes.js': marketCodes,
-  'shopify-values.js': shopifyValues,
-  'store-html.js': storeHtml,
-};
-
-const MINIFIED_SCRIPT = /\.min\.js(\?|$)/;
-const coreScript = typeof document === 'undefined' ? '' : (document.currentScript?.getAttribute('src') ?? '');
-const coreScriptUrl = coreScript ? new URL(coreScript, document.baseURI).href : '';
-
-/** @type {Map<PartName, Promise<unknown>>} Parts loaded or loading. */
-const parts = new Map();
-
-/**
- * The folder parts load from: `partsUrl`, else the core script's own folder. A `partsUrl` must be https or on this
- * site, because the parts run with the same access as the core (the account part holds customer sessions).
- *
- * @throws {Error} For a `partsUrl` that is neither.
- */
-function partsFolder() {
-  if (!cfg.partsUrl) return coreScriptUrl.replace(/[^/]*$/, '');
-  const folder = new URL(cfg.partsUrl, document.baseURI);
-  if (folder.protocol !== 'https:' && folder.origin !== window.location.origin) {
-    throw new Error(`partsUrl must be https or on this site: ${folder.href}`);
-  }
-  return folder.href;
-}
-
-/**
- * @param {PartName} name
- * @param {string} url
- * @returns {Promise<unknown>}
- */
-function loadScript(name, url) {
-  return new Promise((resolve, reject) => {
-    const script = document.createElement('script');
-    script.src = url;
-    script.async = true;
-    script.onload = () => {
-      const { Tether } = /** @type {Window & { Tether?: { __parts?: Record<string, unknown> } }} */ (window);
-      const part = Tether?.__parts?.[name];
-      if (part) resolve(part);
-      else reject(new Error(`${url} did not register`));
-    };
-    script.onerror = () => {
-      parts.delete(name);
-      reject(new Error(`Could not load ${url}. Host it next to the Tether script, or set partsUrl.`));
-    };
-    document.head.appendChild(script);
-  });
-}
-
-/**
- * @template {PartName} Name
- * @param {Name} name
- * @returns {Promise<Parts[Name]>}
- * @throws {Error} (rejected) When the part's file can't be loaded or doesn't register.
- */
-export function loadPart(name) {
-  let loading = parts.get(name);
-  if (!loading) {
-    let folder;
-    try {
-      folder = partsFolder();
-    } catch (error) {
-      return Promise.reject(error instanceof Error ? error : new Error(String(error)));
-    }
-    const suffix = MINIFIED_SCRIPT.test(coreScriptUrl) || !coreScriptUrl ? '.min' : '';
-    loading = loadScript(name, `${folder.replace(/\/?$/, '/')}tether.${name}${suffix}.js`);
-    parts.set(name, loading);
-  }
-  // A part's file is built from the module `Parts[Name]` names (scripts/build.mjs), and registers that module.
-  return /** @type {Promise<Parts[Name]>} */ (loading);
-}
-
-// Parts that load other parts (account → account-pages) use this same loader.
-coreModules['lazy.js'] = { loadPart, coreModules };

package/src/lazy.js

@@ -1,39 +0,0 @@
-/**
- * Optional parts that most pages never need, loaded on first use. In the ESM and Node builds they are dynamic
- * imports, which bundlers split into their own chunks; the `<script>` build swaps this file for `lazy-iife.js`
- * (scripts/build.mjs).
- */
-
-/**
- * @typedef {{
- *   diagnose: typeof import('./diagnose.js'),
- *   markets: typeof import('./markets-ui.js'),
- *   search: typeof import('./search.js'),
- *   extras: typeof import('./extras.js'),
- *   account: typeof import('./account.js'),
- *   'account-pages': typeof import('./account-pages.js'),
- *   analytics: typeof import('./analytics.js'),
- * }} Parts
- */
-/** @typedef {keyof Parts} PartName */
-
-/** @type {{ [Name in PartName]: () => Promise<Parts[Name]> }} */
-const PARTS = {
-  diagnose: () => import('./diagnose.js'),
-  markets: () => import('./markets-ui.js'),
-  search: () => import('./search.js'),
-  extras: () => import('./extras.js'),
-  account: () => import('./account.js'),
-  'account-pages': () => import('./account-pages.js'),
-  analytics: () => import('./analytics.js'),
-};
-
-/**
- * @template {PartName} Name
- * @param {Name} name
- * @returns {Promise<Parts[Name]>}
- */
-export const loadPart = (name) => PARTS[name]();
-
-/** Only the `<script>` build shares its modules with separately loaded parts. */
-export const coreModules = undefined;

package/src/market-codes.js

@@ -1,35 +0,0 @@
-/**
- * Country and language codes as Shopify's `@inContext` takes them. Every market value that reaches a query passes
- * through here: they are written into the query text, so anything else is dropped rather than sent.
- */
-
-/** @typedef {string & { readonly __brand: 'CountryCode' }} CountryCode An ISO 3166-1 alpha-2 code, upper case. */
-/** @typedef {string & { readonly __brand: 'LanguageCode' }} LanguageCode A Shopify `LanguageCode` value. */
-
-const COUNTRY = /^[A-Z]{2}$/;
-/** Cloudflare's codes for an unknown country (XX) and Tor (T1), which a `cf-ipcountry` cookie can carry. */
-const NOT_A_COUNTRY = new Set(['XX', 'T1']);
-/** Shopify `LanguageCode` values with a region. Every other language is its plain ISO 639 code. */
-const REGIONAL_LANGUAGES = new Set(['PT_BR', 'PT_PT', 'ZH_CN', 'ZH_TW']);
-const LANGUAGE = /^[A-Z]{2,3}$/;
-
-/**
- * @param {unknown} value
- * @returns {CountryCode | null} `'de'` → `'DE'`; `null` for anything that is not a country code.
- */
-export function toCountry(value) {
-  const code = (typeof value === 'string' ? value : '').trim().toUpperCase();
-  if (!COUNTRY.test(code) || NOT_A_COUNTRY.has(code)) return null;
-  return /** @type {CountryCode} */ (code);
-}
-
-/**
- * @param {unknown} value
- * @returns {LanguageCode | null} `'de-DE'` → `'DE'`, `'pt-BR'` → `'PT_BR'`, `'en'` → `'EN'`; `null` otherwise.
- */
-export function toLanguage(value) {
-  const raw = (typeof value === 'string' ? value : '').trim().replace('-', '_').toUpperCase();
-  if (REGIONAL_LANGUAGES.has(raw)) return /** @type {LanguageCode} */ (raw);
-  const primary = raw.split('_')[0] ?? '';
-  return LANGUAGE.test(primary) ? /** @type {LanguageCode} */ (primary) : null;
-}

package/src/markets.js

@@ -1,334 +0,0 @@
-/**
- * Markets: which country and language prices, currency and translations follow.
- *
- *   markets: {
- *     detect: true,                       // or a list: ['saved', 'server', 'webflow']
- *     locales: {                          // Webflow Localization: locale subdirectory or <html lang>
- *       de: { country: 'DE', language: 'DE', locale: 'de-DE' },
- *       'fr-be': { country: 'BE', language: 'FR' },
- *     },
- *     cookie: 'tether_country',           // a cookie your server or Worker sets (from cf-ipcountry)
- *     remember: true,                     // keep the visitor's tether-country-select choice
- *   }
- *
- * Sources, first match wins per field:
- *   saved   the visitor's own choice (localStorage), from tether-country-select / Tether.setCountry()
- *   server  window.TETHER_COUNTRY, <meta name="tether-country" content="DE">, or the cookie
- *   webflow locale subdirectory (/de/...) or <html lang="de-DE">, through `locales`
- * then the static `country` / `language` config. Without `detect`, only `saved` applies, so a country select keeps
- * working across pages; `detect: false` turns even that off. Tether never calls an IP lookup service: a country from
- * the visitor's IP only comes from the site's own server (see README).
- */
-import { cfg } from './config.js';
-import { gql } from './client.js';
-import { toCountry, toLanguage } from './market-codes.js';
-/** @import { MarketsConfig } from './config.js' */
-/** @import { CountryCode, LanguageCode } from './market-codes.js' */
-
-/**
- * @typedef {object} Market A market a visitor chose, as `setCountry()` stores it.
- * @property {CountryCode} country
- * @property {LanguageCode | undefined} language
- * @property {string | undefined} locale An `Intl` locale for money and dates.
- */
-
-/** @typedef {'saved' | 'server' | 'webflow'} MarketSource */
-/** @typedef {'country' | 'language' | 'locale'} MarketField */
-/** @typedef {Partial<Record<MarketField, MarketSource>>} MarketSources */
-
-/**
- * @typedef {object} DetectedMarket The fields detection found, and the source each came from.
- * @property {CountryCode} [country]
- * @property {LanguageCode} [language]
- * @property {string} [locale]
- * @property {MarketSources} [sources] Absent when `detect: false` turns detection off.
- */
-
-/**
- * @typedef {object} MarketEnv What detection reads, passed in so it runs on any document.
- * @property {Pick<Document, 'cookie' | 'querySelector' | 'documentElement'> | null} document
- * @property {Pick<Location, 'pathname'> | null} location
- * @property {Pick<Storage, 'getItem'> | null} storage
- * @property {object} global Where `TETHER_COUNTRY` and `TETHER_LANGUAGE` are read from (`window`).
- */
-
-/** @typedef {{ country?: unknown, language?: unknown, locale?: unknown }} MarketHint A source's raw values. */
-
-/** @typedef {{ isoCode: string, name: string }} NamedCode */
-/** @typedef {{ isoCode: string, symbol: string }} Currency */
-/** @typedef {NamedCode & { currency: Currency }} LocalizedCountry */
-/**
- * @typedef {object} Localization The store's markets, from the Storefront API's `localization`.
- * @property {LocalizedCountry} country The country of the current `@inContext`.
- * @property {NamedCode} language
- * @property {(LocalizedCountry & { availableLanguages: NamedCode[] })[]} availableCountries
- */
-
-/** @type {readonly MarketSource[]} */
-const ALL_SOURCES = ['saved', 'server', 'webflow'];
-const DEFAULT_COOKIE = 'tether_country';
-
-/** @returns {string} The localStorage key of the visitor's market: `<prefix>:market:<domain>`. */
-export const storageKey = () => `${cfg.prefix}:market:${cfg.domain}`;
-
-/**
- * Accessing `localStorage` throws where the browser blocks storage (sandboxed frames, cookies turned off); the visitor
- * then simply has no saved market.
- *
- * @returns {Storage | null}
- */
-function localStorageIfAllowed() {
-  if (typeof window === 'undefined') return null;
-  try {
-    return window.localStorage;
-  } catch {
-    return null;
-  }
-}
-
-/** @returns {MarketEnv} The page this script runs on. */
-function pageEnv() {
-  const hasWindow = typeof window !== 'undefined';
-  return {
-    document: typeof document !== 'undefined' ? document : null,
-    location: hasWindow ? window.location : null,
-    storage: localStorageIfAllowed(),
-    global: hasWindow ? window : {},
-  };
-}
-
-/**
- * @param {string} text
- * @returns {unknown} The JSON value, `null` for text that isn't JSON (a key another script wrote).
- */
-function parseJsonOrNull(text) {
-  try {
-    return /** @type {unknown} */ (JSON.parse(text));
-  } catch (error) {
-    if (error instanceof SyntaxError) return null;
-    throw error;
-  }
-}
-
-/**
- * @param {unknown} value
- * @returns {Market | null} `value` as a market, when it has a valid country. A language or locale that isn't valid is
- *   left out.
- */
-function toMarket(value) {
-  if (typeof value !== 'object' || value === null) return null;
-  const country = toCountry(Reflect.get(value, 'country'));
-  if (!country) return null;
-  const locale = /** @type {unknown} */ (Reflect.get(value, 'locale'));
-  return {
-    country,
-    language: toLanguage(Reflect.get(value, 'language')) ?? undefined,
-    locale: typeof locale === 'string' && locale ? locale : undefined,
-  };
-}
-
-/**
- * The visitor's saved market (`setCountry()`, `tether-country-select`), validated: storage is written by other tabs,
- * older versions and other scripts too.
- *
- * @param {Pick<Storage, 'getItem'> | null} [storage] Default `localStorage`, `null` where the browser blocks it.
- * @returns {Market | null} `null` when nothing valid is saved.
- */
-export function readSavedMarket(storage = localStorageIfAllowed()) {
-  const text = storage?.getItem(storageKey());
-  return text ? toMarket(parseJsonOrNull(text)) : null;
-}
-
-/**
- * @param {Pick<Document, 'cookie'> | null} doc
- * @param {string} name
- * @returns {string | null}
- */
-function readCookie(doc, name) {
-  if (!doc || !name) return null;
-  const cookie = doc.cookie
-    .split(';')
-    .map((part) => part.trim())
-    .find((part) => part.startsWith(`${name}=`));
-  return cookie ? decodeURIComponent(cookie.slice(name.length + 1)) : null;
-}
-
-/**
- * @param {MarketsConfig['locales']} locales
- * @param {string | undefined} key
- * @returns {MarketHint | null} The entry for `key`, ignoring case.
- */
-function lookupLocale(locales, key) {
-  if (!locales || !key) return null;
-  const wanted = key.toLowerCase();
-  const found = Object.keys(locales).find((name) => name.toLowerCase() === wanted);
-  return found ? (locales[found] ?? null) : null;
-}
-
-/**
- * @param {MarketsConfig} markets
- * @param {MarketEnv} env
- * @returns {MarketHint}
- */
-function readServerHint(markets, env) {
-  /** @param {string} name */
-  const meta = (name) => env.document?.querySelector(`meta[name="${name}"]`)?.getAttribute('content');
-  return {
-    country:
-      Reflect.get(env.global, 'TETHER_COUNTRY') ||
-      meta('tether-country') ||
-      readCookie(env.document, markets.cookie || DEFAULT_COOKIE),
-    language: Reflect.get(env.global, 'TETHER_LANGUAGE') || meta('tether-language'),
-  };
-}
-
-/**
- * @param {MarketsConfig} markets
- * @param {MarketEnv} env
- * @returns {MarketHint | null}
- */
-function readWebflowLocale(markets, env) {
-  const segment = (env.location?.pathname ?? '/').split('/').find((part) => part !== '');
-  const fromPath = lookupLocale(markets.locales, segment);
-  if (fromPath) return fromPath;
-  const lang = env.document?.documentElement.getAttribute('lang');
-  if (!lang) return null;
-  const mapped = lookupLocale(markets.locales, lang) ?? lookupLocale(markets.locales, lang.split('-')[0]);
-  if (mapped) return { locale: lang, ...mapped };
-  if (markets.locales && markets.strict) return null;
-  // Unmapped: the language from <html lang>, a country only from a region subtag (de-CH -> CH).
-  const region = lang.split('-')[1];
-  return { language: lang, country: region?.length === 2 ? region : null, locale: lang };
-}
-
-/**
- * @param {MarketSource} source
- * @param {MarketsConfig} markets
- * @param {MarketEnv} env
- * @returns {MarketHint | null}
- */
-function readSource(source, markets, env) {
-  switch (source) {
-    case 'saved':
-      return markets.remember === false ? null : readSavedMarket(env.storage);
-    case 'server':
-      return readServerHint(markets, env);
-    case 'webflow':
-      return readWebflowLocale(markets, env);
-  }
-}
-
-/**
- * @param {unknown} name
- * @returns {name is MarketSource}
- */
-const isMarketSource = (name) => ALL_SOURCES.some((source) => source === name);
-
-/**
- * @param {MarketsConfig['detect']} detect
- * @returns {readonly MarketSource[]} Without `detect`, only the visitor's own choice from a country select.
- */
-function sourcesFor(detect) {
-  if (!detect) return ['saved'];
-  if (detect === true) return ALL_SOURCES;
-  // The config comes from the page unvalidated, so a single name or an unknown one can arrive here.
-  return /** @type {unknown[]} */ ([detect].flat()).filter(isMarketSource);
-}
-
-/**
- * The market the page's sources point to. Reads the DOM and storage only, so it can run on any `env`.
- *
- * @param {MarketsConfig | null | undefined} [markets]
- * @param {MarketEnv} [env]
- * @returns {DetectedMarket} Only the fields found; `{}` with `detect: false`.
- */
-export function detectMarket(markets = cfg.markets, env = pageEnv()) {
-  const config = markets ?? {};
-  if (config.detect === false) return {};
-  /** @type {MarketSources} */
-  const sources = {};
-  /** @type {DetectedMarket} */
-  const found = { sources };
-  for (const source of sourcesFor(config.detect)) {
-    const hint = readSource(source, config, env);
-    if (!hint) continue;
-    const country = toCountry(hint.country);
-    const language = toLanguage(hint.language);
-    const locale = typeof hint.locale === 'string' && hint.locale ? hint.locale : null;
-    if (country && !found.country) {
-      found.country = country;
-      sources.country = source;
-    }
-    if (language && !found.language) {
-      found.language = language;
-      sources.language = source;
-    }
-    if (locale && !found.locale) {
-      found.locale = locale;
-      sources.locale = source;
-    }
-  }
-  return found;
-}
-
-/**
- * `setItem` throws when storage is full or blocked (Safari's private mode); the choice then lasts for this page only.
- *
- * @param {string} key
- * @param {string} value
- */
-function storeIfAllowed(key, value) {
-  try {
-    localStorage.setItem(key, value);
-  } catch {
-    return;
-  }
-}
-
-/**
- * Saves the visitor's choice for the next pages, unless `markets.remember` is false.
- *
- * @param {{ country: CountryCode, language?: string | null | undefined, locale?: string | null | undefined }} market
- */
-export function rememberMarket(market) {
-  if (cfg.markets?.remember === false) return;
-  const saved = { country: market.country, language: market.language || undefined, locale: market.locale || undefined };
-  storeIfAllowed(storageKey(), JSON.stringify(saved));
-}
-
-/** @type {Promise<Localization> | null} */
-let localizationPromise = null;
-
-/** Forgets the cached localization, for when country names change language. */
-export function clearLocalization() {
-  localizationPromise = null;
-}
-
-const LOCALIZATION_QUERY = `query TetherLocalization {
-  localization {
-    country { isoCode name currency { isoCode symbol } }
-    language { isoCode name }
-    availableCountries { isoCode name currency { isoCode symbol } availableLanguages { isoCode name } }
-  }
-}`;
-
-/**
- * The countries the store sells to (Shopify Markets), with their currency. Cached per page; a failed request is not
- * cached, so the next call tries again.
- *
- * @returns {Promise<Localization>}
- */
-export function getLocalization() {
-  if (!localizationPromise) {
-    /** @type {Promise<{ localization: Localization }>} */
-    const loading = gql(LOCALIZATION_QUERY);
-    localizationPromise = loading.then(
-      (data) => data.localization,
-      (/** @type {unknown} */ error) => {
-        localizationPromise = null;
-        throw error;
-      },
-    );
-  }
-  return localizationPromise;
-}

package/src/markup.js

@@ -1,64 +0,0 @@
-/**
- * How Tether finds its markup: attribute names carry the configured prefix (`tether-product`, or `wfs-product` with
- * `prefix: 'wfs'`), and so do the selectors and the DOM events built from them.
- */
-import { cfg } from './config.js';
-
-/**
- * @param {string} name
- * @returns {string} The prefixed attribute name: `product` → `tether-product`.
- */
-export const attr = (name) => `${cfg.prefix}-${name}`;
-
-/**
- * @param {string} name
- * @param {string} [value]
- * @returns {string} A selector for the attribute, with that exact value when given.
- */
-export const sel = (name, value) => (value === undefined ? `[${attr(name)}]` : `[${attr(name)}="${value}"]`);
-
-/**
- * @param {Element} el
- * @param {string} name
- */
-export const get = (el, name) => el.getAttribute(attr(name));
-
-/**
- * @param {Element} el
- * @param {string} name
- */
-export const has = (el, name) => el.hasAttribute(attr(name));
-
-/**
- * Tether's attributes go on HTML elements, so matches are typed as such. An SVG element that carries one still has
- * the `style`, `dataset` and attribute methods Tether uses.
- *
- * @param {ParentNode | null | undefined} root
- * @param {string} selector
- * @returns {HTMLElement[]} The matches in `root`, none without a root.
- */
-export function qsa(root, selector) {
-  if (!root) return [];
-  return [.../** @type {NodeListOf<HTMLElement>} */ (root.querySelectorAll(selector))];
-}
-
-/**
- * @param {Element | null | undefined} root
- * @param {string} selector
- * @param {string} scopeSelector
- * @returns {HTMLElement[]} Matches in `root` whose nearest `scopeSelector` ancestor is `root` itself, not a nested
- *   scope.
- */
-export const scoped = (root, selector, scopeSelector) =>
-  qsa(root, selector).filter((el) => el.closest(scopeSelector) === root);
-
-/**
- * Dispatches the bubbling event `<prefix>:<name>`.
- *
- * @param {string} name
- * @param {unknown} [detail]
- * @param {EventTarget} [target]
- */
-export function emit(name, detail, target = document) {
-  target.dispatchEvent(new CustomEvent(`${cfg.prefix}:${name}`, { detail, bubbles: true }));
-}

package/src/parts/account-pages.js

@@ -1,6 +0,0 @@
-// The <script> build's tether.account-pages.js: registers the part where the core script's loader (lazy-iife.js) finds it.
-import * as part from '../account-pages.js';
-
-const { Tether } = /** @type {Window & { Tether?: { __parts: Record<string, unknown> } }} */ (window);
-if (!Tether) throw new Error('tether.account-pages.js runs after the Tether script, which loads it');
-Tether.__parts['account-pages'] = part;

package/src/parts/account.js

@@ -1,6 +0,0 @@
-// The <script> build's tether.account.js: registers the part where the core script's loader (lazy-iife.js) finds it.
-import * as part from '../account.js';
-
-const { Tether } = /** @type {Window & { Tether?: { __parts: Record<string, unknown> } }} */ (window);
-if (!Tether) throw new Error('tether.account.js runs after the Tether script, which loads it');
-Tether.__parts['account'] = part;

package/src/parts/analytics.js

@@ -1,6 +0,0 @@
-// The <script> build's tether.analytics.js: registers the part where the core script's loader (lazy-iife.js) finds it.
-import * as part from '../analytics.js';
-
-const { Tether } = /** @type {Window & { Tether?: { __parts: Record<string, unknown> } }} */ (window);
-if (!Tether) throw new Error('tether.analytics.js runs after the Tether script, which loads it');
-Tether.__parts['analytics'] = part;

package/src/parts/diagnose.js

@@ -1,6 +0,0 @@
-// The <script> build's tether.diagnose.js: registers the part where the core script's loader (lazy-iife.js) finds it.
-import * as part from '../diagnose.js';
-
-const { Tether } = /** @type {Window & { Tether?: { __parts: Record<string, unknown> } }} */ (window);
-if (!Tether) throw new Error('tether.diagnose.js runs after the Tether script, which loads it');
-Tether.__parts['diagnose'] = part;

package/src/parts/extras.js

@@ -1,6 +0,0 @@
-// The <script> build's tether.extras.js: registers the part where the core script's loader (lazy-iife.js) finds it.
-import * as part from '../extras.js';
-
-const { Tether } = /** @type {Window & { Tether?: { __parts: Record<string, unknown> } }} */ (window);
-if (!Tether) throw new Error('tether.extras.js runs after the Tether script, which loads it');
-Tether.__parts['extras'] = part;

package/src/parts/markets.js

@@ -1,6 +0,0 @@
-// The <script> build's tether.markets.js: registers the part where the core script's loader (lazy-iife.js) finds it.
-import * as part from '../markets-ui.js';
-
-const { Tether } = /** @type {Window & { Tether?: { __parts: Record<string, unknown> } }} */ (window);
-if (!Tether) throw new Error('tether.markets.js runs after the Tether script, which loads it');
-Tether.__parts['markets'] = part;

package/src/parts/search.js

@@ -1,6 +0,0 @@
-// The <script> build's tether.search.js: registers the part where the core script's loader (lazy-iife.js) finds it.
-import * as part from '../search.js';
-
-const { Tether } = /** @type {Window & { Tether?: { __parts: Record<string, unknown> } }} */ (window);
-if (!Tether) throw new Error('tether.search.js runs after the Tether script, which loads it');
-Tether.__parts['search'] = part;