@hanzogui/static 2.0.0-rc.41-hanzoai.5

package/src/registerRequire.ts

@@ -0,0 +1,283 @@
+import { register } from 'esbuild-register/dist/node'
+
+import { esbuildIgnoreFilesRegex } from './extractor/bundle'
+import { requireHanzoguiCore } from './helpers/requireHanzoguiCore'
+import type { HanzoguiPlatform } 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
+}
+
+function getStaticExtractionStub(path: string) {
+  switch (path) {
+    case 'expo-constants':
+      return {
+        __esModule: true,
+        default: {
+          executionEnvironment: null,
+        },
+        ExecutionEnvironment: {
+          Bare: 'bare',
+          Standalone: 'standalone',
+          StoreClient: 'storeClient',
+        },
+      }
+    case 'expo-updates':
+      return {
+        __esModule: true,
+        default: {
+          isEnabled: false,
+          isUsingEmbeddedAssets: true,
+        },
+        checkForUpdateAsync: async () => ({ isAvailable: false }),
+        fetchUpdateAsync: async () => ({ isNew: false }),
+        reloadAsync: async () => {},
+      }
+    default:
+      return null
+  }
+}
+
+export function registerRequire(
+  platform: HanzoguiPlatform,
+  { proxyWormImports } = {
+    proxyWormImports: false,
+  }
+) {
+  // already registered
+  if (isRegistered) {
+    return {
+      hanzoguiRequire: require,
+      unregister: () => {},
+    }
+  }
+
+  // capture original resolve BEFORE esbuild-register patches it
+  // so we can use Node's native exports resolution for @hanzogui packages
+  const originalResolveFilename = Module._resolveFilename
+
+  const { unregister } = register({
+    hookIgnoreNodeModules: false,
+    // don't transform @hanzogui packages - they have pre-built dist files
+    hookMatcher: (filename) => {
+      if (
+        filename.includes('@hanzogui') ||
+        /\/hanzogui\/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 @hanzogui packages
+  const tsconfigPatchedResolve = Module._resolveFilename
+  Module._resolveFilename = function (request: string, ...args: any[]) {
+    // for @hanzogui 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 = hanzoguiRequire
+
+  function hanzoguiRequire(this: any, path: string) {
+    const staticExtractionStub = getStaticExtractionStub(path)
+    if (staticExtractionStub) {
+      return staticExtractionStub
+    }
+
+    if (path === 'hanzogui' && platform === 'native') {
+      return og.apply(this, ['hanzogui/native'])
+    }
+
+    if (path === '@hanzogui/core') {
+      return requireHanzoguiCore(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('.hanzogui-dynamic-eval')) {
+        // allow hanzogui and its sub-packages through - they re-export components
+        // with staticConfig needed for dynamic eval optimization.
+        // also allow requires FROM within hanzogui packages (relative imports like ./Separator.cjs)
+        const callerFile = this?.filename || this?.id || ''
+        const isFromHanzoguiPkg =
+          callerFile.includes('@hanzogui') || callerFile.includes('node_modules/hanzogui/')
+        const isFromStaticLoader =
+          !callerFile ||
+          callerFile === '.' ||
+          callerFile === '[eval]' ||
+          callerFile.endsWith('/[eval]') ||
+          callerFile.includes('/code/compiler/static/') ||
+          callerFile.includes('/.hanzogui/')
+
+        if (
+          path === 'hanzogui' ||
+          path.startsWith('@hanzogui/') ||
+          isFromHanzoguiPkg ||
+          isFromStaticLoader
+        ) {
+          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.TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD &&
+        path.includes('hanzogui-dynamic-eval')
+      ) {
+        // ok, dynamic eval fails
+        return
+      }
+      if (allowedIgnores[path] || IGNORES === 'true') {
+        // ignore
+      } else if (!process.env.TAMAGUI_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(
+          `  [hanzogui] skipped "${path}" (set TAMAGUI_IGNORE_BUNDLE_ERRORS="${path}" to silence)`
+        )
+      }
+
+      return proxyWorm
+    }
+  }
+
+  return {
+    hanzoguiRequire,
+    unregister: () => {
+      if (hasWarnedForModules.size) {
+        console.info(
+          `  [hanzogui] skipped loading ${hasWarnedForModules.size} module, see: https://hanzogui.dev/docs/intro/errors#warning-001`
+        )
+        hasWarnedForModules.clear()
+      }
+
+      unregister()
+      isRegistered = false
+      Module.prototype.require = og
+    },
+  }
+}
+
+const IGNORES = process.env.TAMAGUI_IGNORE_BUNDLE_ERRORS
+const extraIgnores =
+  IGNORES === 'true' ? [] : process.env.TAMAGUI_IGNORE_BUNDLE_ERRORS?.split(',')
+
+const knownIgnorableModules = {
+  '@gorhom/bottom-sheet': true,
+  'expo-modules': true,
+  solito: true,
+  'expo-linear-gradient': true,
+  '@expo/vector-icons': true,
+  'hanzogui/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 { HanzoguiOptions } from './types'
+
+import net from 'node:net'
+
+export async function startServer(options: HanzoguiOptions) {
+  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, HanzoguiConfig } from '@hanzogui/core'
+import type { StyleObject } from '@hanzogui/helpers'
+import type { HanzoguiOptions } from '@hanzogui/types'
+import type { ViewStyle } from 'react-native'
+
+import type { LoadedComponents } from './extractor/bundleConfig'
+
+export type HanzoguiPlatform = 'native' | 'web'
+
+export type { HanzoguiOptions, HanzoguiBuildOptions } 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?: HanzoguiPlatform
+}
+
+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: HanzoguiOptionsWithFileInfo
+  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: HanzoguiConfig
+}
+
+export type HanzoguiOptionsWithFileInfo = HanzoguiOptions & {
+  sourcePath?: string
+  allLoadedComponents: LoadedComponents[]
+}
+
+export type ExtractorParseProps = Omit<
+  HanzoguiOptionsWithFileInfo,
+  'allLoadedComponents'
+> & {
+  platform: HanzoguiPlatform
+  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 Hanzogui 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 { HanzoguiOptions } 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: HanzoguiOptions
+  shouldPrintDebug: boolean | 'verbose'
+}
+
+export interface ExtractToNativeTask {
+  type: 'extractToNative'
+  sourceFileName: string
+  sourceCode: string
+  options: HanzoguiOptions
+}
+
+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['_disableLoadHanzogui']) {
+        const cacheKey = JSON.stringify({
+          config: task.options.config,
+          components: task.options.components,
+        })
+
+        if (!configCache.has(cacheKey)) {
+          configCache.set(cacheKey, getWebExtractor().loadHanzogui(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().loadHanzogui(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,KAAmD,CAAA;AAExE,eAAO,MAAM,WAAW,eAA8B,CAAA;AAEtD,eAAO,MAAM,YAAY,qBAC+C,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/loadHanzogui';
+export * from './extractor/watchHanzoguiConfig';
+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,0BAA0B,CAAA;AACxC,cAAc,iCAAiC,CAAA;AAC/C,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"}