@hanzogui/static 2.0.0

package/src/registerRequire.ts

@@ -0,0 +1,236 @@
+import { register } from 'esbuild-register/dist/node'
+
+import { esbuildIgnoreFilesRegex } from './extractor/bundle'
+import { requireGuiCore } from './helpers/requireGuiCore'
+import type { GuiPlatform } from './types'
+
+const nameToPaths = {}
+
+export const getNameToPaths = () => nameToPaths
+
+const Module = require('node:module')
+const proxyWorm = require('@hanzogui/proxy-worm')
+
+let isRegistered = false
+let og: any
+
+const whitelisted = {
+  react: true,
+}
+
+const compiled = {}
+export function setRequireResult(name: string, result: any) {
+  compiled[name] = result
+}
+
+export function registerRequire(
+  platform: GuiPlatform,
+  { proxyWormImports } = {
+    proxyWormImports: false,
+  }
+) {
+  // already registered
+  if (isRegistered) {
+    return {
+      guiRequire: require,
+      unregister: () => {},
+    }
+  }
+
+  // capture original resolve BEFORE esbuild-register patches it
+  // so we can use Node's native exports resolution for @gui packages
+  const originalResolveFilename = Module._resolveFilename
+
+  const { unregister } = register({
+    hookIgnoreNodeModules: false,
+    // don't transform @hanzo/gui packages - they have pre-built dist files
+    hookMatcher: (filename) => {
+      if (
+        filename.includes('@hanzo/gui') ||
+        filename.includes('@gui') ||
+        /\/(hanzo\/gui|gui)\/code\/(core|ui|packages)\//.test(filename)
+      ) {
+        return false
+      }
+      return true
+    },
+  })
+
+  // esbuild-register's registerTsconfigPaths replaces Module._resolveFilename
+  // but tsconfig paths resolution bypasses Node's package exports
+  // we need to restore Node's native resolution for @gui packages
+  const tsconfigPatchedResolve = Module._resolveFilename
+  Module._resolveFilename = function (request: string, ...args: any[]) {
+    // for @gui packages, use Node's native resolution (respects exports)
+    if (request.startsWith('@hanzogui/')) {
+      return originalResolveFilename.call(this, request, ...args)
+    }
+    // for everything else, use tsconfig-paths resolution
+    return tsconfigPatchedResolve.call(this, request, ...args)
+  }
+
+  if (!og) {
+    og = Module.prototype.require // capture esbuild require
+  }
+
+  isRegistered = true
+
+  Module.prototype.require = guiRequire
+
+  function guiRequire(this: any, path: string) {
+    if (path === '@hanzo/gui' && platform === 'native') {
+      return og.apply(this, ['@hanzo/gui/native'])
+    }
+
+    if (path === '@hanzogui/core') {
+      return requireGuiCore(platform, (path) => {
+        return og.apply(this, [path])
+      })
+    }
+
+    if (
+      path in knownIgnorableModules ||
+      path.startsWith('react-native-reanimated') ||
+      esbuildIgnoreFilesRegex.test(path)
+    ) {
+      return proxyWorm
+    }
+
+    if (path in compiled) {
+      return compiled[path]
+    }
+
+    if (path === 'react-native-svg') {
+      return og.apply(this, ['@hanzogui/react-native-svg'])
+    }
+
+    if (path === 'react-native/package.json') {
+      return og.apply(this, ['react-native-web/package.json'])
+    }
+
+    if (
+      path === '@hanzogui/react-native-web-lite' ||
+      path === 'react-native' ||
+      path.startsWith('react-native/')
+    ) {
+      try {
+        return og.apply('react-native')
+      } catch {
+        return og.apply(this, ['@hanzogui/react-native-web-lite'])
+      }
+    }
+
+    if (!whitelisted[path]) {
+      if (proxyWormImports && !path.includes('.gui-dynamic-eval')) {
+        // allow @hanzo/gui and its sub-packages through - they re-export components
+        // with staticConfig needed for dynamic eval optimization.
+        // also allow requires FROM within gui packages (relative imports like ./Separator.cjs)
+        const callerFile = this?.filename || this?.id || ''
+        const isFromGuiPkg =
+          callerFile.includes('@hanzo/gui') || callerFile.includes('@gui') || callerFile.includes('node_modules/@hanzo/')
+        if (path === '@hanzo/gui' || path.startsWith('@hanzogui/') || isFromGuiPkg) {
+          return og.apply(this, [path])
+        }
+        return proxyWorm
+      }
+    }
+
+    try {
+      const out = og.apply(this, arguments)
+      // only for studio disable for now
+      // if (!nameToPaths[path]) {
+      //   if (out && typeof out === 'object') {
+      //     for (const key in out) {
+      //       try {
+      //         const conf = out[key]?.staticConfig as StaticConfig
+      //         if (conf) {
+      //           if (conf.componentName) {
+      //             nameToPaths[conf.componentName] ??= new Set()
+      //             const fullName = path.startsWith('.')
+      //               ? join(`${this.path.replace(/dist(\/cjs)?/, 'src')}`, path)
+      //               : path
+      //             nameToPaths[conf.componentName].add(fullName)
+      //           } else {
+      //             // console.log('no name component', path)
+      //           }
+      //         }
+      //       } catch {
+      //         // ok
+      //       }
+      //     }
+      //   }
+      // }
+      return out
+    } catch (err: any) {
+      if (
+        !process.env.HANZO_GUI_ENABLE_WARN_DYNAMIC_LOAD &&
+        path.includes('gui-dynamic-eval')
+      ) {
+        // ok, dynamic eval fails
+        return
+      }
+      if (allowedIgnores[path] || IGNORES === 'true') {
+        // ignore
+      } else if (!process.env.HANZO_GUI_SHOW_FULL_BUNDLE_ERRORS && !process.env.DEBUG) {
+        if (hasWarnedForModules.has(path)) {
+          // ignore
+        } else {
+          hasWarnedForModules.add(path)
+        }
+      } else {
+        /**
+         * Allow errors to happen, we're just reading config and components but sometimes external modules cause problems
+         * We can't fix every problem, so just swap them out with proxyWorm which is a sort of generic object that can be read.
+         */
+
+        console.warn(
+          `  [hanzo-gui] skipped "${path}" (set HANZO_GUI_IGNORE_BUNDLE_ERRORS="${path}" to silence)`
+        )
+      }
+
+      return proxyWorm
+    }
+  }
+
+  return {
+    guiRequire,
+    unregister: () => {
+      if (hasWarnedForModules.size) {
+        console.info(
+          `  [hanzo-gui] skipped loading ${hasWarnedForModules.size} module, see: https://gui.hanzo.ai/docs/intro/errors#warning-001`
+        )
+        hasWarnedForModules.clear()
+      }
+
+      unregister()
+      isRegistered = false
+      Module.prototype.require = og
+    },
+  }
+}
+
+const IGNORES = process.env.HANZO_GUI_IGNORE_BUNDLE_ERRORS || process.env.HANZO_GUI_IGNORE_BUNDLE_ERRORS
+const extraIgnores =
+  IGNORES === 'true' ? [] : IGNORES?.split(',')
+
+const knownIgnorableModules = {
+  '@gorhom/bottom-sheet': true,
+  'expo-modules': true,
+  solito: true,
+  'expo-linear-gradient': true,
+  '@expo/vector-icons': true,
+  '@hanzo/gui/linear-gradient': true,
+  // animation libraries not needed for static extraction
+  '@emotion/is-prop-valid': true,
+  'framer-motion': true,
+  motion: true,
+  ...Object.fromEntries(extraIgnores?.map((k) => [k, true]) || []),
+}
+
+const hasWarnedForModules = new Set<string>()
+
+const allowedIgnores = {
+  'expo-constants': true,
+  './ExpoHaptics': true,
+  './js/MaskedView': true,
+}

package/src/server.ts

@@ -0,0 +1,43 @@
+import type { GuiOptions } from './types'
+
+import net from 'node:net'
+
+export async function startServer(options: GuiOptions) {
+  const port = await getAvailablePort()
+  const server = net.createServer()
+  server.unref()
+
+  await new Promise((resolve, reject) => {
+    server.on('error', reject)
+    server.on('connection', (conn) => {
+      conn.on('data', (data) => {
+        console.info('got', data.toString())
+      })
+    })
+    server.listen({ port }, () => {
+      const { port } = server.address() as net.AddressInfo
+      server.close(() => {
+        resolve(port)
+      })
+    })
+  })
+}
+
+async function getAvailablePort(port = 8089): Promise<number> {
+  return checkAvailablePort(port).catch(() => getAvailablePort(port + 1))
+}
+
+function checkAvailablePort(port: number) {
+  return new Promise<number>((resolve, reject) => {
+    const server = net.createServer()
+    server.unref()
+    server.on('error', reject)
+
+    server.listen({ port }, () => {
+      const { port } = server.address() as net.AddressInfo
+      server.close(() => {
+        resolve(port)
+      })
+    })
+  })
+}

package/src/types.ts

@@ -0,0 +1,109 @@
+import type { NodePath } from '@babel/traverse'
+import type * as t from '@babel/types'
+import type { PseudoStyles, StaticConfig, GuiConfig } from '@hanzogui/core'
+import type { StyleObject } from '@hanzogui/helpers'
+import type { GuiOptions } from '@hanzogui/types'
+import type { ViewStyle } from 'react-native'
+
+import type { LoadedComponents } from './extractor/bundleConfig'
+
+export type GuiPlatform = 'native' | 'web'
+
+export type { GuiOptions, GuiBuildOptions } from '@hanzogui/types'
+
+export type { StyleObject } from '@hanzogui/helpers'
+
+export type ClassNameObject = t.StringLiteral | t.Expression
+
+export interface CacheObject {
+  [key: string]: any
+}
+
+export interface LogOptions {
+  clear?: boolean
+  timestamp?: boolean
+  error?: Error | null
+}
+
+export interface Logger {
+  info(msg: string, options?: LogOptions): void
+  warn(msg: string, options?: LogOptions): void
+  error(msg: string, options?: LogOptions): void
+}
+
+export type ExtractorOptions = {
+  logger?: Logger
+  platform?: GuiPlatform
+}
+
+export type ExtractedAttrAttr = {
+  type: 'attr'
+  value: t.JSXAttribute | t.JSXSpreadAttribute
+  extraClassNames?: string
+}
+
+export type ExtractedAttrStyle = {
+  type: 'style'
+  value: ViewStyle & PseudoStyles
+  attr?: t.JSXAttribute | t.JSXSpreadAttribute
+  name?: string
+  extraClassNames?: string
+}
+
+export type ExtractedTernaryAttr = {
+  type: 'ternary'
+  value: Ternary
+}
+
+export type ExtractedAttr = ExtractedAttrAttr | ExtractedTernaryAttr | ExtractedAttrStyle
+
+export type ExtractTagProps = {
+  parserProps: GuiOptionsWithFileInfo
+  attrs: ExtractedAttr[]
+  node: t.JSXOpeningElement
+  attemptEval: (exprNode: t.Node, evalFn?: ((node: t.Node) => any) | undefined) => any
+  flatNodeName?: string
+  jsxPath: NodePath<t.JSXElement>
+  programPath: NodePath<t.Program>
+  originalNodeName: string
+  lineNumbers: string
+  filePath: string
+  completeProps: Record<string, any>
+  staticConfig: StaticConfig
+  config: GuiConfig
+}
+
+export type GuiOptionsWithFileInfo = GuiOptions & {
+  sourcePath?: string
+  allLoadedComponents: LoadedComponents[]
+}
+
+export type ExtractorParseProps = Omit<
+  GuiOptionsWithFileInfo,
+  'allLoadedComponents'
+> & {
+  platform: GuiPlatform
+  shouldPrintDebug?: boolean | 'verbose'
+  onExtractTag: (props: ExtractTagProps) => void
+  getFlattenedNode?: (props: { isTextView: boolean; tag: string }) => string
+  extractStyledDefinitions?: boolean
+  // identifer, rule
+  onStyledDefinitionRule?: (identifier: string, rules: string[]) => void
+}
+
+export interface Ternary {
+  test: t.Expression
+  remove: Function
+  consequent: object | null
+  alternate: object | null
+  fontFamily?: string
+  inlineMediaQuery?: string
+}
+
+export type ClassNameToStyleObj = {
+  [key: string]: StyleObject
+}
+
+export interface PluginContext {
+  write: (path: string, rules: { [key: string]: string }) => any
+}

package/src/worker.ts

@@ -0,0 +1,142 @@
+/**
+ * Worker thread implementation for Hanzo GUI extraction
+ * Used by both piscina (async) and synckit (sync for babel)
+ */
+
+import type { BabelFileResult } from '@babel/core'
+import { createExtractor } from './extractor/createExtractor'
+import type { ExtractedResponse } from './extractor/extractToClassNames'
+import { extractToClassNames as extractToClassNamesImpl } from './extractor/extractToClassNames'
+import { extractToNative as extractToNativeImpl } from './extractor/extractToNative'
+import type { GuiOptions } from './types'
+
+// Create extractors lazily to avoid loading unused ones
+let webExtractor: ReturnType<typeof createExtractor> | null = null
+let nativeExtractor: ReturnType<typeof createExtractor> | null = null
+
+function getWebExtractor() {
+  if (!webExtractor) {
+    webExtractor = createExtractor({ platform: 'web' })
+  }
+  return webExtractor
+}
+
+function getNativeExtractor() {
+  if (!nativeExtractor) {
+    nativeExtractor = createExtractor({ platform: 'native' })
+  }
+  return nativeExtractor
+}
+
+// Cache config loading to avoid reloading
+const configCache: Map<string, Promise<any>> = new Map()
+
+export interface ExtractToClassNamesTask {
+  type: 'extractToClassNames'
+  source: string
+  sourcePath: string
+  options: GuiOptions
+  shouldPrintDebug: boolean | 'verbose'
+}
+
+export interface ExtractToNativeTask {
+  type: 'extractToNative'
+  sourceFileName: string
+  sourceCode: string
+  options: GuiOptions
+}
+
+export interface ClearCacheTask {
+  type: 'clearCache'
+}
+
+export type WorkerTask = ExtractToClassNamesTask | ExtractToNativeTask | ClearCacheTask
+
+export type WorkerResult =
+  | { success: true; data: ExtractedResponse | null }
+  | { success: true; data: BabelFileResult }
+  | { success: false; error: string; stack?: string }
+
+/**
+ * Main worker function that handles both extraction types
+ * This is called by piscina for async usage
+ */
+export async function runTask(task: WorkerTask): Promise<WorkerResult> {
+  try {
+    if (task.type === 'extractToClassNames') {
+      // Load web config if needed (with caching)
+      // only skip if both extraction AND debug attrs are disabled (fully disabled)
+      const isFullyDisabled =
+        task.options.disableExtraction && task.options.disableDebugAttr
+      if (!isFullyDisabled && !task.options['_disableLoadGui']) {
+        const cacheKey = JSON.stringify({
+          config: task.options.config,
+          components: task.options.components,
+        })
+
+        if (!configCache.has(cacheKey)) {
+          configCache.set(cacheKey, getWebExtractor().loadGui(task.options))
+        }
+
+        await configCache.get(cacheKey)
+      }
+
+      const result = await extractToClassNamesImpl({
+        extractor: getWebExtractor(),
+        source: task.source,
+        sourcePath: task.sourcePath,
+        options: task.options,
+        shouldPrintDebug: task.shouldPrintDebug,
+      })
+
+      return { success: true, data: result }
+    }
+
+    if (task.type === 'extractToNative') {
+      // Load native config if needed (with caching)
+      const cacheKey = JSON.stringify({
+        config: task.options.config,
+        components: task.options.components,
+      })
+
+      if (!configCache.has(cacheKey)) {
+        configCache.set(cacheKey, getNativeExtractor().loadGui(task.options))
+      }
+
+      await configCache.get(cacheKey)
+
+      // extractToNative uses its own module-level extractor
+      // This is for babel plugin which uses visitor pattern
+      const result = extractToNativeImpl(
+        task.sourceFileName,
+        task.sourceCode,
+        task.options
+      )
+
+      return { success: true, data: result }
+    }
+
+    if (task.type === 'clearCache') {
+      // Clear config caches when files change
+      configCache.clear()
+      return { success: true, data: null }
+    }
+
+    return {
+      success: false,
+      error: `Unknown task type: ${(task as any).type}`,
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    }
+  }
+}
+
+/**
+ * For synckit compatibility - exports the runTask as default
+ * Synckit will call this function synchronously using worker threads
+ */
+export default runTask

package/types/check-dep-versions.d.ts

@@ -0,0 +1,37 @@
+/**
+ * "license": "MIT",
+  "author": "Bryan Mishkin",
+ */
+/** Relevant public data about a dependency. */
+type Dependency = {
+    name: string;
+    isMismatching: boolean;
+    versions: readonly {
+        version: string;
+        packages: readonly {
+            pathRelative: string;
+        }[];
+    }[];
+};
+export declare class CDVC {
+    /** An object mapping each dependency in the workspace to information including the versions found of it. */
+    private readonly dependencies;
+    /**
+     * @param path - path to the workspace root
+     * @param options
+     * @param options.fix - Whether to autofix inconsistencies (using latest version present)
+     * @param options.ignoreDep - Dependency(s) to ignore mismatches for
+     * @param options.includeDepPattern - RegExp(s) of dependency names to ignore mismatches for
+     * @param options.ignorePackage - Workspace package(s) to ignore mismatches for
+     * @param options.ignorePackagePattern - RegExp(s) of package names to ignore mismatches for
+     * @param options.ignorePath - Workspace-relative path(s) of packages to ignore mismatches for
+     * @param options.ignorePathPattern - RegExp(s) of workspace-relative path of packages to ignore mismatches for
+     */
+    constructor(path: string);
+    toMismatchSummary(): string;
+    getDependencies(): readonly Dependency[];
+    getDependency(name: string): Dependency;
+    get hasMismatchingDependencies(): boolean;
+}
+export {};
+//# sourceMappingURL=check-dep-versions.d.ts.map

package/types/check-dep-versions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-dep-versions.d.ts","sourceRoot":"","sources":["../src/check-dep-versions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA8oBH,+CAA+C;AAC/C,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,OAAO,CAAA;IACtB,QAAQ,EAAE,SAAS;QACjB,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,SAAS;YAAE,YAAY,EAAE,MAAM,CAAA;SAAE,EAAE,CAAA;KAC9C,EAAE,CAAA;CACJ,CAAA;AAED,qBAAa,IAAI;IACf,4GAA4G;IAC5G,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAE3C;;;;;;;;;;OAUG;gBACS,IAAI,EAAE,MAAM;IAKjB,iBAAiB,IAAI,MAAM;IAI3B,eAAe,IAAI,SAAS,UAAU,EAAE;IAMxC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAc9C,IAAW,0BAA0B,IAAI,OAAO,CAE/C;CACF"}

package/types/checkDeps.d.ts

@@ -0,0 +1,19 @@
+export declare enum DEPENDENCY_TYPE {
+    dependencies = "dependencies",
+    devDependencies = "devDependencies",
+    optionalDependencies = "optionalDependencies",
+    peerDependencies = "peerDependencies",
+    resolutions = "resolutions"
+}
+export type Options = {
+    depType?: readonly `${DEPENDENCY_TYPE}`[];
+    fix?: boolean;
+    ignoreDep?: readonly string[];
+    ignoreDepPattern?: readonly string[];
+    ignorePackage?: readonly string[];
+    ignorePackagePattern?: readonly string[];
+    ignorePath?: readonly string[];
+    ignorePathPattern?: readonly string[];
+};
+export declare function checkDeps(root: string): Promise<void>;
+//# sourceMappingURL=checkDeps.d.ts.map

package/types/checkDeps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkDeps.d.ts","sourceRoot":"","sources":["../src/checkDeps.ts"],"names":[],"mappings":"AAIA,oBAAY,eAAe;IACzB,YAAY,iBAAiB;IAC7B,eAAe,oBAAoB;IACnC,oBAAoB,yBAAyB;IAC7C,gBAAgB,qBAAqB;IACrC,WAAW,gBAAgB;CAC5B;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,OAAO,CAAC,EAAE,SAAS,GAAG,eAAe,EAAE,EAAE,CAAA;IACzC,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7B,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACjC,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACxC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACtC,CAAA;AA+TD,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,iBA8B3C"}

package/types/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const CSS_FILE_NAME = "__snack.css";
+export declare const MEDIA_SEP = "_";
+export declare const cacheDir: any;
+export declare const FAILED_EVAL: unique symbol;
+export declare const SHOULD_DEBUG: boolean | undefined;
+//# sourceMappingURL=constants.d.ts.map

package/types/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gBAAgB,CAAA;AAG1C,eAAO,MAAM,SAAS,MAAM,CAAA;AAG5B,eAAO,MAAM,QAAQ,KAAoD,CAAA;AAEzE,eAAO,MAAM,WAAW,eAA8B,CAAA;AAEtD,eAAO,MAAM,YAAY,qBACiD,CAAA"}

package/types/exports.d.ts

@@ -0,0 +1,16 @@
+export * from './checkDeps';
+export * from './types';
+export { createExtractor } from './extractor/createExtractor';
+export { literalToAst } from './extractor/literalToAst';
+export * from './constants';
+export * from './extractor/extractToClassNames';
+export * from './extractor/concatClassName';
+export * from './extractor/extractToNative';
+export * from './extractor/extractHelpers';
+export * from './extractor/loadGui';
+export * from './extractor/watchGuiConfig';
+export * from './extractor/createLogger';
+export * from './registerRequire';
+export { detectModuleFormat, clearFormatCache } from './extractor/detectModuleFormat';
+export * from './getPragmaOptions';
+//# sourceMappingURL=exports.d.ts.map

package/types/exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../src/exports.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA;AACvB,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,cAAc,aAAa,CAAA;AAC3B,cAAc,iCAAiC,CAAA;AAC/C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,qBAAqB,CAAA;AACnC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACrF,cAAc,oBAAoB,CAAA"}

package/types/extractor/accessSafe.d.ts

@@ -0,0 +1,3 @@
+import * as t from '@babel/types';
+export declare function accessSafe(obj: t.Expression, member: string): t.LogicalExpression;
+//# sourceMappingURL=accessSafe.d.ts.map

package/types/extractor/accessSafe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessSafe.d.ts","sourceRoot":"","sources":["../../src/extractor/accessSafe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAA;AAIjC,wBAAgB,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC,iBAAiB,CAiBjF"}

package/types/extractor/babelParse.d.ts

@@ -0,0 +1,5 @@
+import * as babelParser from '@babel/parser';
+import type * as t from '@babel/types';
+export declare const parserOptions: babelParser.ParserOptions;
+export declare function babelParse(code: string | Buffer, fileName?: string): t.File;
+//# sourceMappingURL=babelParse.d.ts.map

package/types/extractor/babelParse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babelParse.d.ts","sourceRoot":"","sources":["../../src/extractor/babelParse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,CAAC,MAAM,cAAc,CAAA;AAiBtC,eAAO,MAAM,aAAa,EAAE,WAAW,CAAC,aAGtC,CAAA;AAIF,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,CAW3E"}

package/types/extractor/buildClassName.d.ts

@@ -0,0 +1,7 @@
+import * as t from '@babel/types';
+import type { ClassNameObject } from '../types';
+type Builder = (objects: ClassNameObject[], extras?: string) => t.Expression | t.StringLiteral | null;
+export declare const buildClassName: Builder;
+export declare const buildClassNameLogic: Builder;
+export {};
+//# sourceMappingURL=buildClassName.d.ts.map

package/types/extractor/buildClassName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildClassName.d.ts","sourceRoot":"","sources":["../../src/extractor/buildClassName.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAA;AAEjC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,KAAK,OAAO,GAAG,CACb,OAAO,EAAE,eAAe,EAAE,EAC1B,MAAM,CAAC,EAAE,MAAM,KACZ,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,aAAa,GAAG,IAAI,CAAA;AAE1C,eAAO,MAAM,cAAc,EAAE,OAU5B,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,OAsDjC,CAAA"}