@hanzogui/static 8.3.0 → 8.3.2

package/src/extractor/evaluateAstNode.ts

@@ -21,7 +21,7 @@ export function evaluateAstNode(
   // loop through ObjectExpression keys
   if (t.isObjectExpression(exprNode)) {
     const ret: Record<string, any> = {}
-    for (let idx = -1, len = exprNode.properties.length; ++idx < len; ) {
+    for (let idx = -1, len = exprNode.properties.length; ++idx < len;) {
       const value = exprNode.properties[idx]
 
       if (!t.isObjectProperty(value)) {
@@ -75,7 +75,7 @@ export function evaluateAstNode(
     }
 
     let ret = ''
-    for (let idx = -1, len = exprNode.quasis.length; ++idx < len; ) {
+    for (let idx = -1, len = exprNode.quasis.length; ++idx < len;) {
       const quasi = exprNode.quasis[idx]
       const expr = exprNode.expressions[idx]
       ret += quasi.value.raw

package/src/extractor/extractHelpers.ts

@@ -5,10 +5,10 @@ import type { NodePath } from '@babel/traverse'
 import * as t from '@babel/types'
 import findRoot from 'find-root'
 
-import { memoize } from '../helpers/memoize'
-import type { ExtractedAttr, GuiOptionsWithFileInfo, Ternary } from '../types'
+import { memoize } from '../helpers/memoize.ts'
+import type { ExtractedAttr, GuiOptionsWithFileInfo, Ternary } from '../types.ts'
 
-// import { astToLiteral } from './literalToAst'
+// import { astToLiteral } from './literalToAst.ts'
 
 export function isPresent<T extends object>(
   input: null | void | undefined | T

package/src/extractor/extractMediaStyle.ts

@@ -4,9 +4,9 @@ import type { GuiInternalConfig } from '@hanzogui/core'
 import * as core from '@hanzogui/core'
 import type { ViewStyle } from 'react-native'
 
-import { requireGuiCore } from '../helpers/requireGuiCore'
-import type { StyleObject, GuiOptionsWithFileInfo, Ternary } from '../types'
-import { isPresent, isValidImport } from './extractHelpers'
+import { requireGuiCore } from '../helpers/requireGuiCore.ts'
+import type { StyleObject, GuiOptionsWithFileInfo, Ternary } from '../types.ts'
+import { isPresent, isValidImport } from './extractHelpers.ts'
 
 export function extractMediaStyle(
   props: GuiOptionsWithFileInfo,

package/src/extractor/extractToClassNames.ts

@@ -4,21 +4,21 @@ import * as t from '@babel/types'
 import { mergeProps, StyleObjectIdentifier, StyleObjectRules } from '@hanzogui/web'
 import * as path from 'node:path'
 import * as util from 'node:util'
-import { requireGuiCore } from '../helpers/requireGuiCore'
-import type { StyleObject, GuiOptions, Ternary } from '../types'
-import { babelParse } from './babelParse'
-import { isExtractable } from './extractablePath'
-import type { Extractor } from './createExtractor'
-import { createLogger } from './createLogger'
-import { extractMediaStyle } from './extractMediaStyle'
-import { normalizeTernaries } from './normalizeTernaries'
+import { requireGuiCore } from '../helpers/requireGuiCore.ts'
+import type { StyleObject, GuiOptions, Ternary } from '../types.ts'
+import { babelParse } from './babelParse.ts'
+import { isExtractable } from './extractablePath.ts'
+import type { Extractor } from './createExtractor.ts'
+import { createLogger } from './createLogger.ts'
+import { extractMediaStyle } from './extractMediaStyle.ts'
+import { normalizeTernaries } from './normalizeTernaries.ts'
 import {
   forwardFontFamilyName,
   getFontFamilyNameFromProps,
-} from './propsToFontFamilyCache'
-import { timer } from './timer'
-import { BailOptimizationError } from './errors'
-import { concatClassName } from './concatClassName'
+} from './propsToFontFamilyCache.ts'
+import { timer } from './timer.ts'
+import { BailOptimizationError } from './errors.ts'
+import { concatClassName } from './concatClassName.ts'
 
 export type ExtractedResponse = {
   js: string | Buffer

package/src/extractor/extractToNative.ts

@@ -1,25 +1,28 @@
-import { type BabelFileResult, transformFromAstSync } from '@babel/core'
+import { type FileResult, transformSync } from '@babel/core'
 import generator from '@babel/generator'
 import { declare } from '@babel/helper-plugin-utils'
-import { parse } from '@babel/parser'
 import template from '@babel/template'
 import * as t from '@babel/types'
 import { basename } from 'node:path'
-import { getPragmaOptions } from '../getPragmaOptions'
-import type { GuiOptions } from '../types'
-import { createExtractor } from './createExtractor'
-import { createLogger } from './createLogger'
-import { isSimpleSpread } from './extractHelpers'
-import { literalToAst } from './literalToAst'
-import { loadGuiBuildConfigSync } from './loadGui'
+import { getPragmaOptions } from '../getPragmaOptions.ts'
+import type { GuiOptions } from '../types.ts'
+import { createExtractor } from './createExtractor.ts'
+import { createLogger } from './createLogger.ts'
+import { isSimpleSpread } from './extractHelpers.ts'
+import { literalToAst } from './literalToAst.ts'
+import { loadGuiBuildConfigSync } from './loadGui.ts'
+import { createRequire } from 'node:module'
+import { url } from '../here.ts'
+
+const need = createRequire(url)
 
 const importNativeView = template(`
-const __ReactNativeView = require('react-native').View;
-const __ReactNativeText = require('react-native').Text;
+const __ReactNativeView = need('react-native').View;
+const __ReactNativeText = need('react-native').Text;
 `)
 
 const importStyleSheet = template(`
-const __ReactNativeStyleSheet = require('react-native').StyleSheet;
+const __ReactNativeStyleSheet = need('react-native').StyleSheet;
 `)
 
 const importWithStyle = template.ast(`import { _withStableStyle } from '@hanzogui/core';`)
@@ -32,16 +35,11 @@ export function extractToNative(
   sourceFileName: string,
   sourceCode: string,
   options: GuiOptions
-): BabelFileResult {
-  const ast = parse(sourceCode, {
+): FileResult {
+  const out = transformSync(sourceCode, {
+    plugins: [[getBabelPlugin(), options]],
     sourceType: 'module',
-    plugins: ['jsx', 'typescript'],
-  })
-
-  const babelPlugin = getBabelPlugin()
-
-  const out = transformFromAstSync(ast, sourceCode, {
-    plugins: [[babelPlugin, options]],
+    parserOpts: { plugins: ['jsx', 'typescript'] },
     configFile: false,
     sourceFileName,
     filename: sourceFileName,
@@ -56,7 +54,7 @@ export function extractToNative(
 
 export function getBabelPlugin() {
   return declare((api, options: GuiOptions) => {
-    api.assertVersion(7)
+    api.assertVersion('^7.0.0 || ^8.0.0-0')
     return getBabelParseDefinition(options)
   })
 }

package/src/extractor/findTopmostFunction.ts

@@ -1,24 +1,16 @@
 import type { NodePath } from '@babel/traverse'
 import type * as t from '@babel/types'
 
-export function findTopmostFunction(jsxPath: NodePath<t.JSXElement>) {
-  // get topmost fn
-  const isFunction = (path: NodePath<any>) =>
+export function findTopmostFunction(jsxPath: NodePath<t.JSXElement>): NodePath | null {
+  const isFunction = (path: NodePath) =>
     path.isArrowFunctionExpression() ||
     path.isFunctionDeclaration() ||
     path.isFunctionExpression()
-  let compFn: NodePath<any> | null = jsxPath.findParent(isFunction)
+  let compFn = jsxPath.findParent(isFunction)
   while (compFn) {
     const parent = compFn.findParent(isFunction)
-    if (parent) {
-      compFn = parent
-    } else {
-      break
-    }
-  }
-  if (!compFn) {
-    // console.error(`Couldn't find a topmost function for media query extraction`)
-    return null
+    if (!parent) break
+    compFn = parent
   }
   return compFn
 }

package/src/extractor/getGuiConfigPathFromOptionsConfig.ts

@@ -1,7 +1,7 @@
 import { isAbsolute, join } from 'node:path'
 
 import { statSync } from 'node:fs'
-import type { GuiOptions } from '../types'
+import type { GuiOptions } from '../types.ts'
 
 export function getGuiConfigPathFromOptionsConfig(
   config: NonNullable<GuiOptions['config']>

package/src/extractor/getPrefixLogs.ts

@@ -1,5 +1,5 @@
 import { Color, colorString } from '@hanzogui/cli-color'
-import type { GuiOptions } from '../types'
+import type { GuiOptions } from '../types.ts'
 
 export function getPrefixLogs(options?: GuiOptions) {
   return (

package/src/extractor/getPropValueFromAttributes.ts

@@ -1,7 +1,7 @@
 import generate from '@babel/generator'
 import * as t from '@babel/types'
 
-import { accessSafe } from './accessSafe'
+import { accessSafe } from './accessSafe.ts'
 
 /**
  * getPropValueFromAttributes gets a prop by name from a list of attributes and accounts for potential spread operators.
@@ -25,7 +25,7 @@ export function getPropValueFromAttributes(
 ): t.Expression | null {
   let propIndex = -1
   let jsxAttr: t.JSXAttribute | null = null
-  for (let idx = -1, len = attrs.length; ++idx < len; ) {
+  for (let idx = -1, len = attrs.length; ++idx < len;) {
     const attr = attrs[idx]
     if (t.isJSXAttribute(attr) && attr.name && attr.name.name === propName) {
       propIndex = idx

package/src/extractor/getStaticBindingsForScope.ts

@@ -5,12 +5,12 @@ import { dirname, extname, join, resolve } from 'node:path'
 import type { Binding, NodePath } from '@babel/traverse'
 import * as t from '@babel/types'
 
-import { evaluateAstNode } from './evaluateAstNode'
-import { getSourceModule } from './getSourceModule'
+import { evaluateAstNode } from './evaluateAstNode.ts'
+import { getSourceModule } from './getSourceModule.ts'
 
-// import { fileURLToPath } from 'node:url'
-// // @ts-ignore
-// const __dirname = dirname(fileURLToPath(import.meta.url))
+import { fileURLToPath } from 'node:url'
+import { url } from '../here.ts'
+const extractor = join(dirname(fileURLToPath(url)), 'extractor')
 
 const isLocalImport = (path: string) => path.startsWith('.') || path.startsWith('/')
 
@@ -28,7 +28,7 @@ function resolveImportPath(sourcePath: string, path: string) {
 const cache = new Map()
 const pending = new Map<string, Promise<any>>()
 
-const loadCmd = `${join(__dirname, 'loadFile.js')}`
+const loadCmd = `${join(extractor, 'loadFile.js')}`
 
 let exited = false
 

package/src/extractor/hasTopLevelAwait.ts

@@ -1,5 +1,5 @@
 import traverse from '@babel/traverse'
-import { babelParse } from './babelParse'
+import { babelParse } from './babelParse.ts'
 
 export function hasTopLevelAwait(contents: string, fileName?: string) {
   if (!contents.includes('await')) {

package/src/extractor/literalToAst.ts

@@ -8,13 +8,13 @@ export function literalToAst(literal: any): t.Expression {
     case 'function':
       throw new Error('Unsupported')
     case 'number':
-      return t.numericLiteral(literal)
+      return t.valueToNode(literal)
     case 'string':
       return t.stringLiteral(literal)
     case 'boolean':
       return t.booleanLiteral(literal)
     case 'undefined':
-      return t.unaryExpression('void', t.numericLiteral(0), true)
+      return t.unaryExpression('void', t.valueToNode(0), true)
     default:
       if (Array.isArray(literal)) {
         return t.arrayExpression(literal.map(literalToAst))

package/src/extractor/loadFile.ts

@@ -1,9 +1,14 @@
+import { createRequire } from 'node:module'
+import { url } from '../here.ts'
+
+const need = createRequire(url)
+
 process.on('message', (path) => {
   if (typeof path !== 'string') {
     throw new Error(`Not a string: ${path}`)
   }
   try {
-    const out = require(path)
+    const out = need(path)
     process.send?.(JSON.stringify(out))
   } catch (err) {
     if (err instanceof Error) {

package/src/extractor/loadGui.ts

@@ -1,15 +1,19 @@
 import { basename, dirname, extname, join, relative, resolve } from 'node:path'
+import { createRequire } from 'node:module'
+import { url } from '../here.ts'
+
+const need = createRequire(url)
 // @ts-ignore why
 import { Color, colorLog } from '@hanzogui/cli-color'
 import type { CLIResolvedOptions, CLIUserOptions, GuiOptions } from '@hanzogui/types'
 import type { GuiInternalConfig } from '@hanzogui/web'
 import esbuild from 'esbuild'
 import * as esbuildWasm from 'esbuild-wasm'
-import * as fsExtra from 'fs-extra'
+import fsExtra from 'fs-extra'
 
-import { SHOULD_DEBUG } from '../constants'
-import { requireGuiCore } from '../helpers/requireGuiCore'
-import { getNameToPaths, registerRequire } from '../registerRequire'
+import { SHOULD_DEBUG } from '../constants.ts'
+import { requireGuiCore } from '../helpers/requireGuiCore.ts'
+import { getNameToPaths, registerRequire } from '../registerRequire.ts'
 import {
   type GuiProjectInfo,
   getBundledConfig,
@@ -17,13 +21,13 @@ import {
   hasBundledConfigChanged,
   loadComponentsSync,
   writeGuiCSS,
-} from './bundleConfig'
-import { getGuiConfigPathFromOptionsConfig } from './getGuiConfigPathFromOptionsConfig'
+} from './bundleConfig.ts'
+import { getGuiConfigPathFromOptionsConfig } from './getGuiConfigPathFromOptionsConfig.ts'
 import {
   generateGuiThemes,
   regenerateConfig,
   regenerateConfigSync,
-} from './regenerateConfig'
+} from './regenerateConfig.ts'
 
 const getFilledOptions = (propsIn: Partial<GuiOptions>): GuiOptions => ({
   // defaults
@@ -163,7 +167,7 @@ export async function loadGuiBuildConfigAsync(
       // pass process so process.env works in the config
       const module = { exports: {} as any }
       const fn = new Function('module', 'exports', 'require', 'process', result.code)
-      fn(module, module.exports, require, process)
+      fn(module, module.exports, need, process)
 
       const out = module.exports.default || module.exports
       if (!out || typeof out !== 'object') {
@@ -211,7 +215,7 @@ export function loadGuiBuildConfigSync(hanzoguiOptions: Partial<GuiOptions> | un
   if (fsExtra.existsSync(buildFilePath)) {
     const registered = registerRequire('web')
     try {
-      const out = require(
+      const out = need(
         buildFilePath[0] === '.' ? join(process.cwd(), buildFilePath) : buildFilePath
       ).default
       if (!out) {
@@ -277,7 +281,7 @@ export function loadGuiSync({
       let hanzoguiConfig: GuiInternalConfig | null = null
       if (propsIn.config) {
         const configPath = getGuiConfigPathFromOptionsConfig(propsIn.config)
-        const exp = require(configPath)
+        const exp = need(configPath)
 
         if (!exp || exp._isProxyWorm) {
           throw new Error(`Got a empty / proxied config!`)
@@ -286,7 +290,7 @@ export function loadGuiSync({
         hanzoguiConfig = (exp['default'] || exp['config'] || exp) as GuiInternalConfig
 
         if (!hanzoguiConfig || !hanzoguiConfig.parsed) {
-          const confPath = require.resolve(configPath)
+          const confPath = need.resolve(configPath)
           throw new Error(`Can't find valid config in ${confPath}:
           
   Be sure you "export default" or "export const config" the config.`)
@@ -402,7 +406,7 @@ export async function getOptions({
 
 export function resolveWebOrNativeSpecificEntry(entry: string, platform?: string) {
   const workspaceRoot = resolve()
-  const resolved = require.resolve(entry, { paths: [workspaceRoot] })
+  const resolved = need.resolve(entry, { paths: [workspaceRoot] })
   const ext = extname(resolved)
   const fileName = basename(resolved).replace(ext, '')
   const target = platform || process.env.GUI_TARGET || 'web'

package/src/extractor/normalizeTernaries.ts

@@ -2,8 +2,8 @@ import generate from '@babel/generator'
 import * as t from '@babel/types'
 import { mergeProps } from '@hanzogui/web'
 import invariant from 'invariant'
-import type { Ternary } from '../types'
-import { forwardFontFamilyName } from './propsToFontFamilyCache'
+import type { Ternary } from '../types.ts'
+import { forwardFontFamilyName } from './propsToFontFamilyCache.ts'
 
 export function normalizeTernaries(ternaries: Ternary[]) {
   invariant(
@@ -17,7 +17,7 @@ export function normalizeTernaries(ternaries: Ternary[]) {
 
   const ternariesByKey: { [key: string]: Ternary } = {}
 
-  for (let idx = -1, len = ternaries.length; ++idx < len; ) {
+  for (let idx = -1, len = ternaries.length; ++idx < len;) {
     const { test, consequent, alternate, remove, ...rest } = ternaries[idx]
 
     let ternaryTest = test

package/src/extractor/regenerateConfig.ts

@@ -1,13 +1,17 @@
+import { createRequire } from 'node:module'
 import { dirname, join } from 'node:path'
 
 import { generateThemes, writeGeneratedThemes } from '@hanzogui/generate-themes'
 import type { GuiOptions } from '@hanzogui/types'
-import * as FS from 'fs-extra'
+import FS from 'fs-extra'
+import { url } from '../here.ts'
 
-import { requireGuiCore } from '../helpers/requireGuiCore'
-import type { GuiPlatform } from '../types'
-import type { BundledConfig } from './bundleConfig'
-import { getBundledConfig } from './bundleConfig'
+const need = createRequire(url)
+
+import { requireGuiCore } from '../helpers/requireGuiCore.ts'
+import type { GuiPlatform } from '../types.ts'
+import type { BundledConfig } from './bundleConfig.ts'
+import { getBundledConfig } from './bundleConfig.ts'
 
 const hanzoguiDir = join(process.cwd(), '.hanzogui')
 const confFile = join(hanzoguiDir, 'hanzogui.config.json')
@@ -94,7 +98,7 @@ export async function generateGuiThemes(hanzoguiOptions: GuiOptions, force = fal
 }
 
 const resolveRelativePath = (inputPath: string) =>
-  inputPath.startsWith('.') ? join(process.cwd(), inputPath) : require.resolve(inputPath)
+  inputPath.startsWith('.') ? join(process.cwd(), inputPath) : need.resolve(inputPath)
 
 function cloneDeepSafe(x: any, excludeKeys = {}) {
   if (!x) return x

package/src/extractor/watchGuiConfig.ts

@@ -1,6 +1,10 @@
+import { createRequire } from 'node:module'
 import type { GuiOptions } from '@hanzogui/types'
-import { esbuildWatchFiles, generateThemesAndLog, getOptions } from './loadGui'
-import { regenerateConfig } from './regenerateConfig'
+import { esbuildWatchFiles, generateThemesAndLog, getOptions } from './loadGui.ts'
+import { regenerateConfig } from './regenerateConfig.ts'
+import { url } from '../here.ts'
+
+const need = createRequire(url)
 
 let isWatching = false
 
@@ -43,7 +47,7 @@ export async function watchGuiConfig(hanzoguiOptions: GuiOptions) {
   if (themeBuilderInput) {
     let inputPath = themeBuilderInput
     try {
-      inputPath = require.resolve(themeBuilderInput)
+      inputPath = need.resolve(themeBuilderInput)
     } catch {
       // ok
     }

package/src/helpers/nativeEntry.ts

@@ -0,0 +1,92 @@
+import { readFileSync } from 'node:fs'
+import Module, { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
+import { runInThisContext } from 'node:vm'
+import { transformSync } from 'esbuild'
+import { url } from '../here.ts'
+
+const need = createRequire(url)
+
+type Target = string | { default?: string } | undefined
+type Exports = Record<string, string | Record<string, Target> | undefined>
+
+/**
+ * The file a package's `react-native` export names for a request. Node's own
+ * conditions never select it, so the native pass asks here and requires the
+ * file by path. A request with no such export resolves as Node would.
+ */
+export function nativeEntry(request: string): string {
+  const parts = request.split('/')
+  const name = request.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]
+  const subpath = request.slice(name.length)
+  let manifest: string
+  try {
+    manifest = need.resolve(`${name}/package.json`)
+  } catch {
+    return request
+  }
+  const exports = (need(manifest) as { exports?: Exports }).exports
+  const entry = exports?.[`.${subpath}`]
+  const native = typeof entry === 'string' ? undefined : entry?.['react-native']
+  const file = typeof native === 'string' ? native : native?.default
+  return file ? join(dirname(manifest), file) : request
+}
+
+/** Whether the nearest package.json above a file says `type: module`. */
+const kinds = new Map<string, boolean>()
+function kindOf(dir: string): boolean {
+  const known = kinds.get(dir)
+  if (known !== undefined) return known
+  let found: boolean | undefined
+  try {
+    found =
+      (JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8')) as { type?: string })
+        .type === 'module'
+  } catch {}
+  const parent = dirname(dir)
+  const result = found ?? (parent === dir ? false : kindOf(parent))
+  kinds.set(dir, result)
+  return result
+}
+const inModulePackage = (filename: string) => kindOf(dirname(filename))
+
+/**
+ * An emit of ours is ESM; a native one even says a bare require, as Metro
+ * allows. While this hook is in place, a `.js` file of a module package that
+ * Node is asked to require is translated to CommonJS on the way in and run
+ * through the CommonJS wrapper directly, since the compile hook other loaders
+ * patch would translate it again. It wraps whatever loader is current when it
+ * is installed, so it must go in after esbuild-register's, and comes out first.
+ */
+export function hookModuleJs(): () => void {
+  const extensions = (Module as unknown as { _extensions: Record<string, Loader> })
+    ._extensions
+  const loader = extensions['.js']
+  extensions['.js'] = (module, filename) => {
+    if (!inModulePackage(filename)) return loader(module, filename)
+    const { code } = transformSync(readFileSync(filename, 'utf8'), {
+      format: 'cjs',
+      loader: 'js',
+      target: 'node20',
+      sourcefile: filename,
+    })
+    const own = createRequire(filename)
+    const require = Object.assign((id: string) => module.require(id), {
+      resolve: own.resolve,
+      cache: own.cache,
+    })
+    const fn = runInThisContext(Module.wrap(code), { filename }) as (
+      exports: unknown,
+      require: unknown,
+      module: NodeModule,
+      filename: string,
+      dirname: string
+    ) => void
+    fn.call(module.exports, module.exports, require, module, filename, dirname(filename))
+  }
+  return () => {
+    extensions['.js'] = loader
+  }
+}
+
+type Loader = (module: NodeModule, filename: string) => void

package/src/helpers/requireGuiCore.ts

@@ -1,10 +1,15 @@
 // this allows us to swap between core native and web in the same process:
 
-import type { GuiPlatform } from '../types'
+import { createRequire } from 'node:module'
+import type { GuiPlatform } from '../types.ts'
+import { url } from '../here.ts'
+import { nativeEntry } from './nativeEntry.ts'
+
+const need = createRequire(url)
 
 export function requireGuiCore(
   platform: GuiPlatform,
-  ogRequire: Function = require
+  ogRequire: Function = need
 ): typeof import('@hanzogui/core') {
   if (!platform) {
     throw new Error(`No platform given to requireGuiCore`)
@@ -17,7 +22,7 @@ export function requireGuiCore(
   process.env.GUI_KEEP_THEMES ||= '1'
 
   const exported = ogRequire(
-    platform === 'native' ? '@hanzogui/core/native' : '@hanzogui/core'
+    platform === 'native' ? nativeEntry('@hanzogui/core') : '@hanzogui/core'
   )
 
   // restore back

package/src/here.cjs.ts

@@ -0,0 +1,6 @@
+import { pathToFileURL } from 'node:url'
+
+export const url = pathToFileURL(__filename).href
+
+export const load = async (file: string): Promise<Record<string, unknown>> =>
+  require(file)

package/src/here.ts

@@ -0,0 +1,8 @@
+import { pathToFileURL } from 'node:url'
+
+// This module's own URL. A require made from it resolves from this package.
+export const url = import.meta.url
+
+// A file loaded as a module, the way this emit loads modules.
+export const load = (file: string): Promise<Record<string, unknown>> =>
+  import(pathToFileURL(file).href)

package/src/index.ts

@@ -1,4 +1,4 @@
 // cjs/esm interop
-import * as Static1 from './exports'
-export * from './exports'
+import * as Static1 from './exports.ts'
+export * from './exports.ts'
 export default Static1