var GetIntrinsic = require('get-intrinsic');

// 获取静态方法
GetIntrinsic('%Math.pow%'); // Math.pow 的缓存引用

// 获取实例方法
GetIntrinsic('%Array.prototype.push%'); // Array.prototype.push 的缓存引用

// 即使原方法被删除，缓存的方法仍可工作
delete Array.prototype.push;
GetIntrinsic('%Array.prototype.push%').call(arr, 4); // 仍然有效

get-intrinsic
├── function-bind@^1.1.2          # Function.prototype.bind 的 polyfill
├── hasown@^2.0.2                 # Object.prototype.hasOwnProperty 的封装
├── has-symbols@^1.1.0            # Symbol 支持检测
├── es-errors@^1.3.0              # JS Error 构造函数的缓存
├── es-object-atoms@^1.1.1        # Object 相关原子操作
│   └── es-errors@^1.3.0
├── es-define-property@^1.0.1     # Object.defineProperty 的封装
│   └── get-intrinsic@^1.2.4
├── gopd@^1.2.0                   # Object.getOwnPropertyDescriptor 的封装
│   └── es-errors@^1.3.0
├── get-proto@^1.0.1              # Object.getPrototypeOf 的封装
│   └── es-errors@^1.3.0
├── call-bind-apply-helpers@^1.0.2 # call/apply 的辅助函数
│   ├── es-errors@^1.3.0
│   └── function-bind@^1.1.2
├── math-intrinsics@^1.1.0        # Math 相关内置函数
├── async-function@^1.0.0         # AsyncFunction 构造函数检测
├── async-generator-function@^1.0.0 # AsyncGeneratorFunction 检测
└── generator-function@^2.0.0     # GeneratorFunction 构造函数检测

// 简化版核心结构
'use strict';

// 1. 首先缓存所有基础依赖
var $Object = require('es-object-atoms');      // Object 基础操作
var $Error = require('es-errors');             // Error 构造函数
var $TypeError = require('es-errors/type');    // TypeError 构造函数
var hasSymbols = require('has-symbols')();     // Symbol 支持检测
var getProto = require('get-proto');           // getPrototypeOf

// 2. 核心：Intrinsics 缓存表
var INTRINSICS = {
  // 基础构造函数
  '%Array%': Array,
  '%Object%': $Object,
  '%Function%': Function,
  '%Error%': $Error,
  '%TypeError%': $TypeError,

  // 实例方法（使用 % 语法）
  '%Array.prototype.push%': Array.prototype.push,
  '%Object.prototype.toString%': Object.prototype.toString,

  // 条件性存在的特性（typeof 检测）
  '%Map%': typeof Map === 'undefined' ? undefined : Map,
  '%Symbol%': hasSymbols ? Symbol : undefined,

  // 需要延迟求值的（如 GeneratorFunction）
  '%GeneratorFunction%': needsEval,
};

// 3. 路径解析器：将 %Array.prototype.push% 解析为路径数组
function stringToPath(string) {
  // 解析类似 "Array.prototype.push" 的路径
  // 处理引号、转义字符等
}

// 4. 核心导出函数
module.exports = function GetIntrinsic(name, allowMissing) {
  var parts = stringToPath(name);
  var value = INTRINSICS['%' + parts[0] + '%'];

  // 逐层深入对象属性
  for (var i = 1; i < parts.length; i++) {
    value = value[parts[i]];
  }

  return value;
};

// es-errors/index.js - 极简缓存模式
'use strict';

module.exports = Error;

// es-errors/type.js
'use strict';
module.exports = TypeError;

// es-errors/range.js
'use strict';
module.exports = RangeError;

// 其他：eval.js, ref.js, syntax.js, uri.js...

// es-object-atoms/index.js
'use strict';

module.exports = Object;

// es-object-atoms/ToObject.js
'use strict';
var $Object = require('./');

// ES 规范: ToObject 抽象操作
module.exports = function ToObject(value) {
  if (value == null) {  // null 或 undefined
    throw new TypeError('Cannot convert undefined or null to object');
  }
  return $Object(value);
};

// es-object-atoms/RequireObjectCoercible.js
'use strict';

// ES 规范: RequireObjectCoercible 抽象操作
module.exports = function RequireObjectCoercible(value) {
  if (value == null) {
    throw new TypeError('Cannot call method on ' + value);
  }
  return value;
};

// es-object-atoms/isObject.js
'use strict';

module.exports = function isObject(value) {
  return typeof value === 'object' && value !== null;
};

// has-symbols/index.js
'use strict';

var origSymbol = typeof Symbol !== 'undefined' && Symbol;

module.exports = function hasNativeSymbols() {
  if (typeof origSymbol !== 'function') { return false; }

  // 检测 Symbol 是否为原生实现（非 polyfill）
  // 通过检测 Symbol 的特性来判断
  return true; // 简化版，实际有更多检测逻辑
};

// has-symbols/shams.js
// 检测是否存在 sham/polyfill 实现（非原生）

'use strict'; // 所有文件都使用严格模式

// 1. 立即缓存全局引用（在模块顶部）
var $Object = Object;
var $Array = Array;

// 2. 使用本地变量引用原型方法
var $call = Function.prototype.call;
var $apply = Function.prototype.apply;

// 3. 导出一个纯函数，操作缓存的引用
module.exports = function safeOperation(obj, ...args) {
  // 使用缓存的 $call 而非 obj.method.call
  return $call.call($Array.prototype.push, obj, ...args);
};

// get-intrinsic 中的延迟求值
var needsEval = {}; // 标记需要延迟求值的 intrinsics

var INTRINSICS = {
  '%GeneratorFunction%': needsEval,  // 无法直接获取
};

function doEval(name) {
  var value;
  if (name === '%GeneratorFunction%') {
    // 通过创建一个 generator 函数来获取其构造函数
    value = function*(){}.constructor;
  }
  INTRINSICS[name] = value; // 缓存结果
  return value;
}

// 使用时
if (value === needsEval) {
  value = doEval(intrinsicName);
}

// 别名映射表
var LEGACY_ALIASES = {
  '%ArrayPrototype%': ['Array', 'prototype'],
  '%ArrayProto_push%': ['Array', 'prototype', 'push'],
  '%ObjProto_toString%': ['Object', 'prototype', 'toString'],
};

// 路径字符串解析（处理引号和转义）
var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;

function stringToPath(string) {
  var result = [];
  string.replace(rePropName, function(match, number, quote, subString) {
    result.push(quote ? subString.replace(/\\(\)?/g, '$1') : (number || match));
  });
  return result;
}